helpers.gen.go (159729B)
1 // THIS IS A GENERATED FILE, DO NOT EDIT BY HAND 2 // GoToSocial 3 // Copyright (C) GoToSocial Authors admin@gotosocial.org 4 // SPDX-License-Identifier: AGPL-3.0-or-later 5 // 6 // This program is free software: you can redistribute it and/or modify 7 // it under the terms of the GNU Affero General Public License as published by 8 // the Free Software Foundation, either version 3 of the License, or 9 // (at your option) any later version. 10 // 11 // This program is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU Affero General Public License for more details. 15 // 16 // You should have received a copy of the GNU Affero General Public License 17 // along with this program. If not, see <http://www.gnu.org/licenses/>. 18 19 package config 20 21 import ( 22 "time" 23 24 "codeberg.org/gruf/go-bytesize" 25 ) 26 27 // GetLogLevel safely fetches the Configuration value for state's 'LogLevel' field 28 func (st *ConfigState) GetLogLevel() (v string) { 29 st.mutex.Lock() 30 v = st.config.LogLevel 31 st.mutex.Unlock() 32 return 33 } 34 35 // SetLogLevel safely sets the Configuration value for state's 'LogLevel' field 36 func (st *ConfigState) SetLogLevel(v string) { 37 st.mutex.Lock() 38 defer st.mutex.Unlock() 39 st.config.LogLevel = v 40 st.reloadToViper() 41 } 42 43 // LogLevelFlag returns the flag name for the 'LogLevel' field 44 func LogLevelFlag() string { return "log-level" } 45 46 // GetLogLevel safely fetches the value for global configuration 'LogLevel' field 47 func GetLogLevel() string { return global.GetLogLevel() } 48 49 // SetLogLevel safely sets the value for global configuration 'LogLevel' field 50 func SetLogLevel(v string) { global.SetLogLevel(v) } 51 52 // GetLogDbQueries safely fetches the Configuration value for state's 'LogDbQueries' field 53 func (st *ConfigState) GetLogDbQueries() (v bool) { 54 st.mutex.Lock() 55 v = st.config.LogDbQueries 56 st.mutex.Unlock() 57 return 58 } 59 60 // SetLogDbQueries safely sets the Configuration value for state's 'LogDbQueries' field 61 func (st *ConfigState) SetLogDbQueries(v bool) { 62 st.mutex.Lock() 63 defer st.mutex.Unlock() 64 st.config.LogDbQueries = v 65 st.reloadToViper() 66 } 67 68 // LogDbQueriesFlag returns the flag name for the 'LogDbQueries' field 69 func LogDbQueriesFlag() string { return "log-db-queries" } 70 71 // GetLogDbQueries safely fetches the value for global configuration 'LogDbQueries' field 72 func GetLogDbQueries() bool { return global.GetLogDbQueries() } 73 74 // SetLogDbQueries safely sets the value for global configuration 'LogDbQueries' field 75 func SetLogDbQueries(v bool) { global.SetLogDbQueries(v) } 76 77 // GetLogClientIP safely fetches the Configuration value for state's 'LogClientIP' field 78 func (st *ConfigState) GetLogClientIP() (v bool) { 79 st.mutex.Lock() 80 v = st.config.LogClientIP 81 st.mutex.Unlock() 82 return 83 } 84 85 // SetLogClientIP safely sets the Configuration value for state's 'LogClientIP' field 86 func (st *ConfigState) SetLogClientIP(v bool) { 87 st.mutex.Lock() 88 defer st.mutex.Unlock() 89 st.config.LogClientIP = v 90 st.reloadToViper() 91 } 92 93 // LogClientIPFlag returns the flag name for the 'LogClientIP' field 94 func LogClientIPFlag() string { return "log-client-ip" } 95 96 // GetLogClientIP safely fetches the value for global configuration 'LogClientIP' field 97 func GetLogClientIP() bool { return global.GetLogClientIP() } 98 99 // SetLogClientIP safely sets the value for global configuration 'LogClientIP' field 100 func SetLogClientIP(v bool) { global.SetLogClientIP(v) } 101 102 // GetApplicationName safely fetches the Configuration value for state's 'ApplicationName' field 103 func (st *ConfigState) GetApplicationName() (v string) { 104 st.mutex.Lock() 105 v = st.config.ApplicationName 106 st.mutex.Unlock() 107 return 108 } 109 110 // SetApplicationName safely sets the Configuration value for state's 'ApplicationName' field 111 func (st *ConfigState) SetApplicationName(v string) { 112 st.mutex.Lock() 113 defer st.mutex.Unlock() 114 st.config.ApplicationName = v 115 st.reloadToViper() 116 } 117 118 // ApplicationNameFlag returns the flag name for the 'ApplicationName' field 119 func ApplicationNameFlag() string { return "application-name" } 120 121 // GetApplicationName safely fetches the value for global configuration 'ApplicationName' field 122 func GetApplicationName() string { return global.GetApplicationName() } 123 124 // SetApplicationName safely sets the value for global configuration 'ApplicationName' field 125 func SetApplicationName(v string) { global.SetApplicationName(v) } 126 127 // GetLandingPageUser safely fetches the Configuration value for state's 'LandingPageUser' field 128 func (st *ConfigState) GetLandingPageUser() (v string) { 129 st.mutex.Lock() 130 v = st.config.LandingPageUser 131 st.mutex.Unlock() 132 return 133 } 134 135 // SetLandingPageUser safely sets the Configuration value for state's 'LandingPageUser' field 136 func (st *ConfigState) SetLandingPageUser(v string) { 137 st.mutex.Lock() 138 defer st.mutex.Unlock() 139 st.config.LandingPageUser = v 140 st.reloadToViper() 141 } 142 143 // LandingPageUserFlag returns the flag name for the 'LandingPageUser' field 144 func LandingPageUserFlag() string { return "landing-page-user" } 145 146 // GetLandingPageUser safely fetches the value for global configuration 'LandingPageUser' field 147 func GetLandingPageUser() string { return global.GetLandingPageUser() } 148 149 // SetLandingPageUser safely sets the value for global configuration 'LandingPageUser' field 150 func SetLandingPageUser(v string) { global.SetLandingPageUser(v) } 151 152 // GetConfigPath safely fetches the Configuration value for state's 'ConfigPath' field 153 func (st *ConfigState) GetConfigPath() (v string) { 154 st.mutex.Lock() 155 v = st.config.ConfigPath 156 st.mutex.Unlock() 157 return 158 } 159 160 // SetConfigPath safely sets the Configuration value for state's 'ConfigPath' field 161 func (st *ConfigState) SetConfigPath(v string) { 162 st.mutex.Lock() 163 defer st.mutex.Unlock() 164 st.config.ConfigPath = v 165 st.reloadToViper() 166 } 167 168 // ConfigPathFlag returns the flag name for the 'ConfigPath' field 169 func ConfigPathFlag() string { return "config-path" } 170 171 // GetConfigPath safely fetches the value for global configuration 'ConfigPath' field 172 func GetConfigPath() string { return global.GetConfigPath() } 173 174 // SetConfigPath safely sets the value for global configuration 'ConfigPath' field 175 func SetConfigPath(v string) { global.SetConfigPath(v) } 176 177 // GetHost safely fetches the Configuration value for state's 'Host' field 178 func (st *ConfigState) GetHost() (v string) { 179 st.mutex.Lock() 180 v = st.config.Host 181 st.mutex.Unlock() 182 return 183 } 184 185 // SetHost safely sets the Configuration value for state's 'Host' field 186 func (st *ConfigState) SetHost(v string) { 187 st.mutex.Lock() 188 defer st.mutex.Unlock() 189 st.config.Host = v 190 st.reloadToViper() 191 } 192 193 // HostFlag returns the flag name for the 'Host' field 194 func HostFlag() string { return "host" } 195 196 // GetHost safely fetches the value for global configuration 'Host' field 197 func GetHost() string { return global.GetHost() } 198 199 // SetHost safely sets the value for global configuration 'Host' field 200 func SetHost(v string) { global.SetHost(v) } 201 202 // GetAccountDomain safely fetches the Configuration value for state's 'AccountDomain' field 203 func (st *ConfigState) GetAccountDomain() (v string) { 204 st.mutex.Lock() 205 v = st.config.AccountDomain 206 st.mutex.Unlock() 207 return 208 } 209 210 // SetAccountDomain safely sets the Configuration value for state's 'AccountDomain' field 211 func (st *ConfigState) SetAccountDomain(v string) { 212 st.mutex.Lock() 213 defer st.mutex.Unlock() 214 st.config.AccountDomain = v 215 st.reloadToViper() 216 } 217 218 // AccountDomainFlag returns the flag name for the 'AccountDomain' field 219 func AccountDomainFlag() string { return "account-domain" } 220 221 // GetAccountDomain safely fetches the value for global configuration 'AccountDomain' field 222 func GetAccountDomain() string { return global.GetAccountDomain() } 223 224 // SetAccountDomain safely sets the value for global configuration 'AccountDomain' field 225 func SetAccountDomain(v string) { global.SetAccountDomain(v) } 226 227 // GetProtocol safely fetches the Configuration value for state's 'Protocol' field 228 func (st *ConfigState) GetProtocol() (v string) { 229 st.mutex.Lock() 230 v = st.config.Protocol 231 st.mutex.Unlock() 232 return 233 } 234 235 // SetProtocol safely sets the Configuration value for state's 'Protocol' field 236 func (st *ConfigState) SetProtocol(v string) { 237 st.mutex.Lock() 238 defer st.mutex.Unlock() 239 st.config.Protocol = v 240 st.reloadToViper() 241 } 242 243 // ProtocolFlag returns the flag name for the 'Protocol' field 244 func ProtocolFlag() string { return "protocol" } 245 246 // GetProtocol safely fetches the value for global configuration 'Protocol' field 247 func GetProtocol() string { return global.GetProtocol() } 248 249 // SetProtocol safely sets the value for global configuration 'Protocol' field 250 func SetProtocol(v string) { global.SetProtocol(v) } 251 252 // GetBindAddress safely fetches the Configuration value for state's 'BindAddress' field 253 func (st *ConfigState) GetBindAddress() (v string) { 254 st.mutex.Lock() 255 v = st.config.BindAddress 256 st.mutex.Unlock() 257 return 258 } 259 260 // SetBindAddress safely sets the Configuration value for state's 'BindAddress' field 261 func (st *ConfigState) SetBindAddress(v string) { 262 st.mutex.Lock() 263 defer st.mutex.Unlock() 264 st.config.BindAddress = v 265 st.reloadToViper() 266 } 267 268 // BindAddressFlag returns the flag name for the 'BindAddress' field 269 func BindAddressFlag() string { return "bind-address" } 270 271 // GetBindAddress safely fetches the value for global configuration 'BindAddress' field 272 func GetBindAddress() string { return global.GetBindAddress() } 273 274 // SetBindAddress safely sets the value for global configuration 'BindAddress' field 275 func SetBindAddress(v string) { global.SetBindAddress(v) } 276 277 // GetPort safely fetches the Configuration value for state's 'Port' field 278 func (st *ConfigState) GetPort() (v int) { 279 st.mutex.Lock() 280 v = st.config.Port 281 st.mutex.Unlock() 282 return 283 } 284 285 // SetPort safely sets the Configuration value for state's 'Port' field 286 func (st *ConfigState) SetPort(v int) { 287 st.mutex.Lock() 288 defer st.mutex.Unlock() 289 st.config.Port = v 290 st.reloadToViper() 291 } 292 293 // PortFlag returns the flag name for the 'Port' field 294 func PortFlag() string { return "port" } 295 296 // GetPort safely fetches the value for global configuration 'Port' field 297 func GetPort() int { return global.GetPort() } 298 299 // SetPort safely sets the value for global configuration 'Port' field 300 func SetPort(v int) { global.SetPort(v) } 301 302 // GetTrustedProxies safely fetches the Configuration value for state's 'TrustedProxies' field 303 func (st *ConfigState) GetTrustedProxies() (v []string) { 304 st.mutex.Lock() 305 v = st.config.TrustedProxies 306 st.mutex.Unlock() 307 return 308 } 309 310 // SetTrustedProxies safely sets the Configuration value for state's 'TrustedProxies' field 311 func (st *ConfigState) SetTrustedProxies(v []string) { 312 st.mutex.Lock() 313 defer st.mutex.Unlock() 314 st.config.TrustedProxies = v 315 st.reloadToViper() 316 } 317 318 // TrustedProxiesFlag returns the flag name for the 'TrustedProxies' field 319 func TrustedProxiesFlag() string { return "trusted-proxies" } 320 321 // GetTrustedProxies safely fetches the value for global configuration 'TrustedProxies' field 322 func GetTrustedProxies() []string { return global.GetTrustedProxies() } 323 324 // SetTrustedProxies safely sets the value for global configuration 'TrustedProxies' field 325 func SetTrustedProxies(v []string) { global.SetTrustedProxies(v) } 326 327 // GetSoftwareVersion safely fetches the Configuration value for state's 'SoftwareVersion' field 328 func (st *ConfigState) GetSoftwareVersion() (v string) { 329 st.mutex.Lock() 330 v = st.config.SoftwareVersion 331 st.mutex.Unlock() 332 return 333 } 334 335 // SetSoftwareVersion safely sets the Configuration value for state's 'SoftwareVersion' field 336 func (st *ConfigState) SetSoftwareVersion(v string) { 337 st.mutex.Lock() 338 defer st.mutex.Unlock() 339 st.config.SoftwareVersion = v 340 st.reloadToViper() 341 } 342 343 // SoftwareVersionFlag returns the flag name for the 'SoftwareVersion' field 344 func SoftwareVersionFlag() string { return "software-version" } 345 346 // GetSoftwareVersion safely fetches the value for global configuration 'SoftwareVersion' field 347 func GetSoftwareVersion() string { return global.GetSoftwareVersion() } 348 349 // SetSoftwareVersion safely sets the value for global configuration 'SoftwareVersion' field 350 func SetSoftwareVersion(v string) { global.SetSoftwareVersion(v) } 351 352 // GetDbType safely fetches the Configuration value for state's 'DbType' field 353 func (st *ConfigState) GetDbType() (v string) { 354 st.mutex.Lock() 355 v = st.config.DbType 356 st.mutex.Unlock() 357 return 358 } 359 360 // SetDbType safely sets the Configuration value for state's 'DbType' field 361 func (st *ConfigState) SetDbType(v string) { 362 st.mutex.Lock() 363 defer st.mutex.Unlock() 364 st.config.DbType = v 365 st.reloadToViper() 366 } 367 368 // DbTypeFlag returns the flag name for the 'DbType' field 369 func DbTypeFlag() string { return "db-type" } 370 371 // GetDbType safely fetches the value for global configuration 'DbType' field 372 func GetDbType() string { return global.GetDbType() } 373 374 // SetDbType safely sets the value for global configuration 'DbType' field 375 func SetDbType(v string) { global.SetDbType(v) } 376 377 // GetDbAddress safely fetches the Configuration value for state's 'DbAddress' field 378 func (st *ConfigState) GetDbAddress() (v string) { 379 st.mutex.Lock() 380 v = st.config.DbAddress 381 st.mutex.Unlock() 382 return 383 } 384 385 // SetDbAddress safely sets the Configuration value for state's 'DbAddress' field 386 func (st *ConfigState) SetDbAddress(v string) { 387 st.mutex.Lock() 388 defer st.mutex.Unlock() 389 st.config.DbAddress = v 390 st.reloadToViper() 391 } 392 393 // DbAddressFlag returns the flag name for the 'DbAddress' field 394 func DbAddressFlag() string { return "db-address" } 395 396 // GetDbAddress safely fetches the value for global configuration 'DbAddress' field 397 func GetDbAddress() string { return global.GetDbAddress() } 398 399 // SetDbAddress safely sets the value for global configuration 'DbAddress' field 400 func SetDbAddress(v string) { global.SetDbAddress(v) } 401 402 // GetDbPort safely fetches the Configuration value for state's 'DbPort' field 403 func (st *ConfigState) GetDbPort() (v int) { 404 st.mutex.Lock() 405 v = st.config.DbPort 406 st.mutex.Unlock() 407 return 408 } 409 410 // SetDbPort safely sets the Configuration value for state's 'DbPort' field 411 func (st *ConfigState) SetDbPort(v int) { 412 st.mutex.Lock() 413 defer st.mutex.Unlock() 414 st.config.DbPort = v 415 st.reloadToViper() 416 } 417 418 // DbPortFlag returns the flag name for the 'DbPort' field 419 func DbPortFlag() string { return "db-port" } 420 421 // GetDbPort safely fetches the value for global configuration 'DbPort' field 422 func GetDbPort() int { return global.GetDbPort() } 423 424 // SetDbPort safely sets the value for global configuration 'DbPort' field 425 func SetDbPort(v int) { global.SetDbPort(v) } 426 427 // GetDbUser safely fetches the Configuration value for state's 'DbUser' field 428 func (st *ConfigState) GetDbUser() (v string) { 429 st.mutex.Lock() 430 v = st.config.DbUser 431 st.mutex.Unlock() 432 return 433 } 434 435 // SetDbUser safely sets the Configuration value for state's 'DbUser' field 436 func (st *ConfigState) SetDbUser(v string) { 437 st.mutex.Lock() 438 defer st.mutex.Unlock() 439 st.config.DbUser = v 440 st.reloadToViper() 441 } 442 443 // DbUserFlag returns the flag name for the 'DbUser' field 444 func DbUserFlag() string { return "db-user" } 445 446 // GetDbUser safely fetches the value for global configuration 'DbUser' field 447 func GetDbUser() string { return global.GetDbUser() } 448 449 // SetDbUser safely sets the value for global configuration 'DbUser' field 450 func SetDbUser(v string) { global.SetDbUser(v) } 451 452 // GetDbPassword safely fetches the Configuration value for state's 'DbPassword' field 453 func (st *ConfigState) GetDbPassword() (v string) { 454 st.mutex.Lock() 455 v = st.config.DbPassword 456 st.mutex.Unlock() 457 return 458 } 459 460 // SetDbPassword safely sets the Configuration value for state's 'DbPassword' field 461 func (st *ConfigState) SetDbPassword(v string) { 462 st.mutex.Lock() 463 defer st.mutex.Unlock() 464 st.config.DbPassword = v 465 st.reloadToViper() 466 } 467 468 // DbPasswordFlag returns the flag name for the 'DbPassword' field 469 func DbPasswordFlag() string { return "db-password" } 470 471 // GetDbPassword safely fetches the value for global configuration 'DbPassword' field 472 func GetDbPassword() string { return global.GetDbPassword() } 473 474 // SetDbPassword safely sets the value for global configuration 'DbPassword' field 475 func SetDbPassword(v string) { global.SetDbPassword(v) } 476 477 // GetDbDatabase safely fetches the Configuration value for state's 'DbDatabase' field 478 func (st *ConfigState) GetDbDatabase() (v string) { 479 st.mutex.Lock() 480 v = st.config.DbDatabase 481 st.mutex.Unlock() 482 return 483 } 484 485 // SetDbDatabase safely sets the Configuration value for state's 'DbDatabase' field 486 func (st *ConfigState) SetDbDatabase(v string) { 487 st.mutex.Lock() 488 defer st.mutex.Unlock() 489 st.config.DbDatabase = v 490 st.reloadToViper() 491 } 492 493 // DbDatabaseFlag returns the flag name for the 'DbDatabase' field 494 func DbDatabaseFlag() string { return "db-database" } 495 496 // GetDbDatabase safely fetches the value for global configuration 'DbDatabase' field 497 func GetDbDatabase() string { return global.GetDbDatabase() } 498 499 // SetDbDatabase safely sets the value for global configuration 'DbDatabase' field 500 func SetDbDatabase(v string) { global.SetDbDatabase(v) } 501 502 // GetDbTLSMode safely fetches the Configuration value for state's 'DbTLSMode' field 503 func (st *ConfigState) GetDbTLSMode() (v string) { 504 st.mutex.Lock() 505 v = st.config.DbTLSMode 506 st.mutex.Unlock() 507 return 508 } 509 510 // SetDbTLSMode safely sets the Configuration value for state's 'DbTLSMode' field 511 func (st *ConfigState) SetDbTLSMode(v string) { 512 st.mutex.Lock() 513 defer st.mutex.Unlock() 514 st.config.DbTLSMode = v 515 st.reloadToViper() 516 } 517 518 // DbTLSModeFlag returns the flag name for the 'DbTLSMode' field 519 func DbTLSModeFlag() string { return "db-tls-mode" } 520 521 // GetDbTLSMode safely fetches the value for global configuration 'DbTLSMode' field 522 func GetDbTLSMode() string { return global.GetDbTLSMode() } 523 524 // SetDbTLSMode safely sets the value for global configuration 'DbTLSMode' field 525 func SetDbTLSMode(v string) { global.SetDbTLSMode(v) } 526 527 // GetDbTLSCACert safely fetches the Configuration value for state's 'DbTLSCACert' field 528 func (st *ConfigState) GetDbTLSCACert() (v string) { 529 st.mutex.Lock() 530 v = st.config.DbTLSCACert 531 st.mutex.Unlock() 532 return 533 } 534 535 // SetDbTLSCACert safely sets the Configuration value for state's 'DbTLSCACert' field 536 func (st *ConfigState) SetDbTLSCACert(v string) { 537 st.mutex.Lock() 538 defer st.mutex.Unlock() 539 st.config.DbTLSCACert = v 540 st.reloadToViper() 541 } 542 543 // DbTLSCACertFlag returns the flag name for the 'DbTLSCACert' field 544 func DbTLSCACertFlag() string { return "db-tls-ca-cert" } 545 546 // GetDbTLSCACert safely fetches the value for global configuration 'DbTLSCACert' field 547 func GetDbTLSCACert() string { return global.GetDbTLSCACert() } 548 549 // SetDbTLSCACert safely sets the value for global configuration 'DbTLSCACert' field 550 func SetDbTLSCACert(v string) { global.SetDbTLSCACert(v) } 551 552 // GetDbMaxOpenConnsMultiplier safely fetches the Configuration value for state's 'DbMaxOpenConnsMultiplier' field 553 func (st *ConfigState) GetDbMaxOpenConnsMultiplier() (v int) { 554 st.mutex.Lock() 555 v = st.config.DbMaxOpenConnsMultiplier 556 st.mutex.Unlock() 557 return 558 } 559 560 // SetDbMaxOpenConnsMultiplier safely sets the Configuration value for state's 'DbMaxOpenConnsMultiplier' field 561 func (st *ConfigState) SetDbMaxOpenConnsMultiplier(v int) { 562 st.mutex.Lock() 563 defer st.mutex.Unlock() 564 st.config.DbMaxOpenConnsMultiplier = v 565 st.reloadToViper() 566 } 567 568 // DbMaxOpenConnsMultiplierFlag returns the flag name for the 'DbMaxOpenConnsMultiplier' field 569 func DbMaxOpenConnsMultiplierFlag() string { return "db-max-open-conns-multiplier" } 570 571 // GetDbMaxOpenConnsMultiplier safely fetches the value for global configuration 'DbMaxOpenConnsMultiplier' field 572 func GetDbMaxOpenConnsMultiplier() int { return global.GetDbMaxOpenConnsMultiplier() } 573 574 // SetDbMaxOpenConnsMultiplier safely sets the value for global configuration 'DbMaxOpenConnsMultiplier' field 575 func SetDbMaxOpenConnsMultiplier(v int) { global.SetDbMaxOpenConnsMultiplier(v) } 576 577 // GetDbSqliteJournalMode safely fetches the Configuration value for state's 'DbSqliteJournalMode' field 578 func (st *ConfigState) GetDbSqliteJournalMode() (v string) { 579 st.mutex.Lock() 580 v = st.config.DbSqliteJournalMode 581 st.mutex.Unlock() 582 return 583 } 584 585 // SetDbSqliteJournalMode safely sets the Configuration value for state's 'DbSqliteJournalMode' field 586 func (st *ConfigState) SetDbSqliteJournalMode(v string) { 587 st.mutex.Lock() 588 defer st.mutex.Unlock() 589 st.config.DbSqliteJournalMode = v 590 st.reloadToViper() 591 } 592 593 // DbSqliteJournalModeFlag returns the flag name for the 'DbSqliteJournalMode' field 594 func DbSqliteJournalModeFlag() string { return "db-sqlite-journal-mode" } 595 596 // GetDbSqliteJournalMode safely fetches the value for global configuration 'DbSqliteJournalMode' field 597 func GetDbSqliteJournalMode() string { return global.GetDbSqliteJournalMode() } 598 599 // SetDbSqliteJournalMode safely sets the value for global configuration 'DbSqliteJournalMode' field 600 func SetDbSqliteJournalMode(v string) { global.SetDbSqliteJournalMode(v) } 601 602 // GetDbSqliteSynchronous safely fetches the Configuration value for state's 'DbSqliteSynchronous' field 603 func (st *ConfigState) GetDbSqliteSynchronous() (v string) { 604 st.mutex.Lock() 605 v = st.config.DbSqliteSynchronous 606 st.mutex.Unlock() 607 return 608 } 609 610 // SetDbSqliteSynchronous safely sets the Configuration value for state's 'DbSqliteSynchronous' field 611 func (st *ConfigState) SetDbSqliteSynchronous(v string) { 612 st.mutex.Lock() 613 defer st.mutex.Unlock() 614 st.config.DbSqliteSynchronous = v 615 st.reloadToViper() 616 } 617 618 // DbSqliteSynchronousFlag returns the flag name for the 'DbSqliteSynchronous' field 619 func DbSqliteSynchronousFlag() string { return "db-sqlite-synchronous" } 620 621 // GetDbSqliteSynchronous safely fetches the value for global configuration 'DbSqliteSynchronous' field 622 func GetDbSqliteSynchronous() string { return global.GetDbSqliteSynchronous() } 623 624 // SetDbSqliteSynchronous safely sets the value for global configuration 'DbSqliteSynchronous' field 625 func SetDbSqliteSynchronous(v string) { global.SetDbSqliteSynchronous(v) } 626 627 // GetDbSqliteCacheSize safely fetches the Configuration value for state's 'DbSqliteCacheSize' field 628 func (st *ConfigState) GetDbSqliteCacheSize() (v bytesize.Size) { 629 st.mutex.Lock() 630 v = st.config.DbSqliteCacheSize 631 st.mutex.Unlock() 632 return 633 } 634 635 // SetDbSqliteCacheSize safely sets the Configuration value for state's 'DbSqliteCacheSize' field 636 func (st *ConfigState) SetDbSqliteCacheSize(v bytesize.Size) { 637 st.mutex.Lock() 638 defer st.mutex.Unlock() 639 st.config.DbSqliteCacheSize = v 640 st.reloadToViper() 641 } 642 643 // DbSqliteCacheSizeFlag returns the flag name for the 'DbSqliteCacheSize' field 644 func DbSqliteCacheSizeFlag() string { return "db-sqlite-cache-size" } 645 646 // GetDbSqliteCacheSize safely fetches the value for global configuration 'DbSqliteCacheSize' field 647 func GetDbSqliteCacheSize() bytesize.Size { return global.GetDbSqliteCacheSize() } 648 649 // SetDbSqliteCacheSize safely sets the value for global configuration 'DbSqliteCacheSize' field 650 func SetDbSqliteCacheSize(v bytesize.Size) { global.SetDbSqliteCacheSize(v) } 651 652 // GetDbSqliteBusyTimeout safely fetches the Configuration value for state's 'DbSqliteBusyTimeout' field 653 func (st *ConfigState) GetDbSqliteBusyTimeout() (v time.Duration) { 654 st.mutex.Lock() 655 v = st.config.DbSqliteBusyTimeout 656 st.mutex.Unlock() 657 return 658 } 659 660 // SetDbSqliteBusyTimeout safely sets the Configuration value for state's 'DbSqliteBusyTimeout' field 661 func (st *ConfigState) SetDbSqliteBusyTimeout(v time.Duration) { 662 st.mutex.Lock() 663 defer st.mutex.Unlock() 664 st.config.DbSqliteBusyTimeout = v 665 st.reloadToViper() 666 } 667 668 // DbSqliteBusyTimeoutFlag returns the flag name for the 'DbSqliteBusyTimeout' field 669 func DbSqliteBusyTimeoutFlag() string { return "db-sqlite-busy-timeout" } 670 671 // GetDbSqliteBusyTimeout safely fetches the value for global configuration 'DbSqliteBusyTimeout' field 672 func GetDbSqliteBusyTimeout() time.Duration { return global.GetDbSqliteBusyTimeout() } 673 674 // SetDbSqliteBusyTimeout safely sets the value for global configuration 'DbSqliteBusyTimeout' field 675 func SetDbSqliteBusyTimeout(v time.Duration) { global.SetDbSqliteBusyTimeout(v) } 676 677 // GetWebTemplateBaseDir safely fetches the Configuration value for state's 'WebTemplateBaseDir' field 678 func (st *ConfigState) GetWebTemplateBaseDir() (v string) { 679 st.mutex.Lock() 680 v = st.config.WebTemplateBaseDir 681 st.mutex.Unlock() 682 return 683 } 684 685 // SetWebTemplateBaseDir safely sets the Configuration value for state's 'WebTemplateBaseDir' field 686 func (st *ConfigState) SetWebTemplateBaseDir(v string) { 687 st.mutex.Lock() 688 defer st.mutex.Unlock() 689 st.config.WebTemplateBaseDir = v 690 st.reloadToViper() 691 } 692 693 // WebTemplateBaseDirFlag returns the flag name for the 'WebTemplateBaseDir' field 694 func WebTemplateBaseDirFlag() string { return "web-template-base-dir" } 695 696 // GetWebTemplateBaseDir safely fetches the value for global configuration 'WebTemplateBaseDir' field 697 func GetWebTemplateBaseDir() string { return global.GetWebTemplateBaseDir() } 698 699 // SetWebTemplateBaseDir safely sets the value for global configuration 'WebTemplateBaseDir' field 700 func SetWebTemplateBaseDir(v string) { global.SetWebTemplateBaseDir(v) } 701 702 // GetWebAssetBaseDir safely fetches the Configuration value for state's 'WebAssetBaseDir' field 703 func (st *ConfigState) GetWebAssetBaseDir() (v string) { 704 st.mutex.Lock() 705 v = st.config.WebAssetBaseDir 706 st.mutex.Unlock() 707 return 708 } 709 710 // SetWebAssetBaseDir safely sets the Configuration value for state's 'WebAssetBaseDir' field 711 func (st *ConfigState) SetWebAssetBaseDir(v string) { 712 st.mutex.Lock() 713 defer st.mutex.Unlock() 714 st.config.WebAssetBaseDir = v 715 st.reloadToViper() 716 } 717 718 // WebAssetBaseDirFlag returns the flag name for the 'WebAssetBaseDir' field 719 func WebAssetBaseDirFlag() string { return "web-asset-base-dir" } 720 721 // GetWebAssetBaseDir safely fetches the value for global configuration 'WebAssetBaseDir' field 722 func GetWebAssetBaseDir() string { return global.GetWebAssetBaseDir() } 723 724 // SetWebAssetBaseDir safely sets the value for global configuration 'WebAssetBaseDir' field 725 func SetWebAssetBaseDir(v string) { global.SetWebAssetBaseDir(v) } 726 727 // GetInstanceExposePeers safely fetches the Configuration value for state's 'InstanceExposePeers' field 728 func (st *ConfigState) GetInstanceExposePeers() (v bool) { 729 st.mutex.Lock() 730 v = st.config.InstanceExposePeers 731 st.mutex.Unlock() 732 return 733 } 734 735 // SetInstanceExposePeers safely sets the Configuration value for state's 'InstanceExposePeers' field 736 func (st *ConfigState) SetInstanceExposePeers(v bool) { 737 st.mutex.Lock() 738 defer st.mutex.Unlock() 739 st.config.InstanceExposePeers = v 740 st.reloadToViper() 741 } 742 743 // InstanceExposePeersFlag returns the flag name for the 'InstanceExposePeers' field 744 func InstanceExposePeersFlag() string { return "instance-expose-peers" } 745 746 // GetInstanceExposePeers safely fetches the value for global configuration 'InstanceExposePeers' field 747 func GetInstanceExposePeers() bool { return global.GetInstanceExposePeers() } 748 749 // SetInstanceExposePeers safely sets the value for global configuration 'InstanceExposePeers' field 750 func SetInstanceExposePeers(v bool) { global.SetInstanceExposePeers(v) } 751 752 // GetInstanceExposeSuspended safely fetches the Configuration value for state's 'InstanceExposeSuspended' field 753 func (st *ConfigState) GetInstanceExposeSuspended() (v bool) { 754 st.mutex.Lock() 755 v = st.config.InstanceExposeSuspended 756 st.mutex.Unlock() 757 return 758 } 759 760 // SetInstanceExposeSuspended safely sets the Configuration value for state's 'InstanceExposeSuspended' field 761 func (st *ConfigState) SetInstanceExposeSuspended(v bool) { 762 st.mutex.Lock() 763 defer st.mutex.Unlock() 764 st.config.InstanceExposeSuspended = v 765 st.reloadToViper() 766 } 767 768 // InstanceExposeSuspendedFlag returns the flag name for the 'InstanceExposeSuspended' field 769 func InstanceExposeSuspendedFlag() string { return "instance-expose-suspended" } 770 771 // GetInstanceExposeSuspended safely fetches the value for global configuration 'InstanceExposeSuspended' field 772 func GetInstanceExposeSuspended() bool { return global.GetInstanceExposeSuspended() } 773 774 // SetInstanceExposeSuspended safely sets the value for global configuration 'InstanceExposeSuspended' field 775 func SetInstanceExposeSuspended(v bool) { global.SetInstanceExposeSuspended(v) } 776 777 // GetInstanceExposeSuspendedWeb safely fetches the Configuration value for state's 'InstanceExposeSuspendedWeb' field 778 func (st *ConfigState) GetInstanceExposeSuspendedWeb() (v bool) { 779 st.mutex.Lock() 780 v = st.config.InstanceExposeSuspendedWeb 781 st.mutex.Unlock() 782 return 783 } 784 785 // SetInstanceExposeSuspendedWeb safely sets the Configuration value for state's 'InstanceExposeSuspendedWeb' field 786 func (st *ConfigState) SetInstanceExposeSuspendedWeb(v bool) { 787 st.mutex.Lock() 788 defer st.mutex.Unlock() 789 st.config.InstanceExposeSuspendedWeb = v 790 st.reloadToViper() 791 } 792 793 // InstanceExposeSuspendedWebFlag returns the flag name for the 'InstanceExposeSuspendedWeb' field 794 func InstanceExposeSuspendedWebFlag() string { return "instance-expose-suspended-web" } 795 796 // GetInstanceExposeSuspendedWeb safely fetches the value for global configuration 'InstanceExposeSuspendedWeb' field 797 func GetInstanceExposeSuspendedWeb() bool { return global.GetInstanceExposeSuspendedWeb() } 798 799 // SetInstanceExposeSuspendedWeb safely sets the value for global configuration 'InstanceExposeSuspendedWeb' field 800 func SetInstanceExposeSuspendedWeb(v bool) { global.SetInstanceExposeSuspendedWeb(v) } 801 802 // GetInstanceExposePublicTimeline safely fetches the Configuration value for state's 'InstanceExposePublicTimeline' field 803 func (st *ConfigState) GetInstanceExposePublicTimeline() (v bool) { 804 st.mutex.Lock() 805 v = st.config.InstanceExposePublicTimeline 806 st.mutex.Unlock() 807 return 808 } 809 810 // SetInstanceExposePublicTimeline safely sets the Configuration value for state's 'InstanceExposePublicTimeline' field 811 func (st *ConfigState) SetInstanceExposePublicTimeline(v bool) { 812 st.mutex.Lock() 813 defer st.mutex.Unlock() 814 st.config.InstanceExposePublicTimeline = v 815 st.reloadToViper() 816 } 817 818 // InstanceExposePublicTimelineFlag returns the flag name for the 'InstanceExposePublicTimeline' field 819 func InstanceExposePublicTimelineFlag() string { return "instance-expose-public-timeline" } 820 821 // GetInstanceExposePublicTimeline safely fetches the value for global configuration 'InstanceExposePublicTimeline' field 822 func GetInstanceExposePublicTimeline() bool { return global.GetInstanceExposePublicTimeline() } 823 824 // SetInstanceExposePublicTimeline safely sets the value for global configuration 'InstanceExposePublicTimeline' field 825 func SetInstanceExposePublicTimeline(v bool) { global.SetInstanceExposePublicTimeline(v) } 826 827 // GetInstanceDeliverToSharedInboxes safely fetches the Configuration value for state's 'InstanceDeliverToSharedInboxes' field 828 func (st *ConfigState) GetInstanceDeliverToSharedInboxes() (v bool) { 829 st.mutex.Lock() 830 v = st.config.InstanceDeliverToSharedInboxes 831 st.mutex.Unlock() 832 return 833 } 834 835 // SetInstanceDeliverToSharedInboxes safely sets the Configuration value for state's 'InstanceDeliverToSharedInboxes' field 836 func (st *ConfigState) SetInstanceDeliverToSharedInboxes(v bool) { 837 st.mutex.Lock() 838 defer st.mutex.Unlock() 839 st.config.InstanceDeliverToSharedInboxes = v 840 st.reloadToViper() 841 } 842 843 // InstanceDeliverToSharedInboxesFlag returns the flag name for the 'InstanceDeliverToSharedInboxes' field 844 func InstanceDeliverToSharedInboxesFlag() string { return "instance-deliver-to-shared-inboxes" } 845 846 // GetInstanceDeliverToSharedInboxes safely fetches the value for global configuration 'InstanceDeliverToSharedInboxes' field 847 func GetInstanceDeliverToSharedInboxes() bool { return global.GetInstanceDeliverToSharedInboxes() } 848 849 // SetInstanceDeliverToSharedInboxes safely sets the value for global configuration 'InstanceDeliverToSharedInboxes' field 850 func SetInstanceDeliverToSharedInboxes(v bool) { global.SetInstanceDeliverToSharedInboxes(v) } 851 852 // GetAccountsRegistrationOpen safely fetches the Configuration value for state's 'AccountsRegistrationOpen' field 853 func (st *ConfigState) GetAccountsRegistrationOpen() (v bool) { 854 st.mutex.Lock() 855 v = st.config.AccountsRegistrationOpen 856 st.mutex.Unlock() 857 return 858 } 859 860 // SetAccountsRegistrationOpen safely sets the Configuration value for state's 'AccountsRegistrationOpen' field 861 func (st *ConfigState) SetAccountsRegistrationOpen(v bool) { 862 st.mutex.Lock() 863 defer st.mutex.Unlock() 864 st.config.AccountsRegistrationOpen = v 865 st.reloadToViper() 866 } 867 868 // AccountsRegistrationOpenFlag returns the flag name for the 'AccountsRegistrationOpen' field 869 func AccountsRegistrationOpenFlag() string { return "accounts-registration-open" } 870 871 // GetAccountsRegistrationOpen safely fetches the value for global configuration 'AccountsRegistrationOpen' field 872 func GetAccountsRegistrationOpen() bool { return global.GetAccountsRegistrationOpen() } 873 874 // SetAccountsRegistrationOpen safely sets the value for global configuration 'AccountsRegistrationOpen' field 875 func SetAccountsRegistrationOpen(v bool) { global.SetAccountsRegistrationOpen(v) } 876 877 // GetAccountsApprovalRequired safely fetches the Configuration value for state's 'AccountsApprovalRequired' field 878 func (st *ConfigState) GetAccountsApprovalRequired() (v bool) { 879 st.mutex.Lock() 880 v = st.config.AccountsApprovalRequired 881 st.mutex.Unlock() 882 return 883 } 884 885 // SetAccountsApprovalRequired safely sets the Configuration value for state's 'AccountsApprovalRequired' field 886 func (st *ConfigState) SetAccountsApprovalRequired(v bool) { 887 st.mutex.Lock() 888 defer st.mutex.Unlock() 889 st.config.AccountsApprovalRequired = v 890 st.reloadToViper() 891 } 892 893 // AccountsApprovalRequiredFlag returns the flag name for the 'AccountsApprovalRequired' field 894 func AccountsApprovalRequiredFlag() string { return "accounts-approval-required" } 895 896 // GetAccountsApprovalRequired safely fetches the value for global configuration 'AccountsApprovalRequired' field 897 func GetAccountsApprovalRequired() bool { return global.GetAccountsApprovalRequired() } 898 899 // SetAccountsApprovalRequired safely sets the value for global configuration 'AccountsApprovalRequired' field 900 func SetAccountsApprovalRequired(v bool) { global.SetAccountsApprovalRequired(v) } 901 902 // GetAccountsReasonRequired safely fetches the Configuration value for state's 'AccountsReasonRequired' field 903 func (st *ConfigState) GetAccountsReasonRequired() (v bool) { 904 st.mutex.Lock() 905 v = st.config.AccountsReasonRequired 906 st.mutex.Unlock() 907 return 908 } 909 910 // SetAccountsReasonRequired safely sets the Configuration value for state's 'AccountsReasonRequired' field 911 func (st *ConfigState) SetAccountsReasonRequired(v bool) { 912 st.mutex.Lock() 913 defer st.mutex.Unlock() 914 st.config.AccountsReasonRequired = v 915 st.reloadToViper() 916 } 917 918 // AccountsReasonRequiredFlag returns the flag name for the 'AccountsReasonRequired' field 919 func AccountsReasonRequiredFlag() string { return "accounts-reason-required" } 920 921 // GetAccountsReasonRequired safely fetches the value for global configuration 'AccountsReasonRequired' field 922 func GetAccountsReasonRequired() bool { return global.GetAccountsReasonRequired() } 923 924 // SetAccountsReasonRequired safely sets the value for global configuration 'AccountsReasonRequired' field 925 func SetAccountsReasonRequired(v bool) { global.SetAccountsReasonRequired(v) } 926 927 // GetAccountsAllowCustomCSS safely fetches the Configuration value for state's 'AccountsAllowCustomCSS' field 928 func (st *ConfigState) GetAccountsAllowCustomCSS() (v bool) { 929 st.mutex.Lock() 930 v = st.config.AccountsAllowCustomCSS 931 st.mutex.Unlock() 932 return 933 } 934 935 // SetAccountsAllowCustomCSS safely sets the Configuration value for state's 'AccountsAllowCustomCSS' field 936 func (st *ConfigState) SetAccountsAllowCustomCSS(v bool) { 937 st.mutex.Lock() 938 defer st.mutex.Unlock() 939 st.config.AccountsAllowCustomCSS = v 940 st.reloadToViper() 941 } 942 943 // AccountsAllowCustomCSSFlag returns the flag name for the 'AccountsAllowCustomCSS' field 944 func AccountsAllowCustomCSSFlag() string { return "accounts-allow-custom-css" } 945 946 // GetAccountsAllowCustomCSS safely fetches the value for global configuration 'AccountsAllowCustomCSS' field 947 func GetAccountsAllowCustomCSS() bool { return global.GetAccountsAllowCustomCSS() } 948 949 // SetAccountsAllowCustomCSS safely sets the value for global configuration 'AccountsAllowCustomCSS' field 950 func SetAccountsAllowCustomCSS(v bool) { global.SetAccountsAllowCustomCSS(v) } 951 952 // GetAccountsCustomCSSLength safely fetches the Configuration value for state's 'AccountsCustomCSSLength' field 953 func (st *ConfigState) GetAccountsCustomCSSLength() (v int) { 954 st.mutex.Lock() 955 v = st.config.AccountsCustomCSSLength 956 st.mutex.Unlock() 957 return 958 } 959 960 // SetAccountsCustomCSSLength safely sets the Configuration value for state's 'AccountsCustomCSSLength' field 961 func (st *ConfigState) SetAccountsCustomCSSLength(v int) { 962 st.mutex.Lock() 963 defer st.mutex.Unlock() 964 st.config.AccountsCustomCSSLength = v 965 st.reloadToViper() 966 } 967 968 // AccountsCustomCSSLengthFlag returns the flag name for the 'AccountsCustomCSSLength' field 969 func AccountsCustomCSSLengthFlag() string { return "accounts-custom-css-length" } 970 971 // GetAccountsCustomCSSLength safely fetches the value for global configuration 'AccountsCustomCSSLength' field 972 func GetAccountsCustomCSSLength() int { return global.GetAccountsCustomCSSLength() } 973 974 // SetAccountsCustomCSSLength safely sets the value for global configuration 'AccountsCustomCSSLength' field 975 func SetAccountsCustomCSSLength(v int) { global.SetAccountsCustomCSSLength(v) } 976 977 // GetMediaImageMaxSize safely fetches the Configuration value for state's 'MediaImageMaxSize' field 978 func (st *ConfigState) GetMediaImageMaxSize() (v bytesize.Size) { 979 st.mutex.Lock() 980 v = st.config.MediaImageMaxSize 981 st.mutex.Unlock() 982 return 983 } 984 985 // SetMediaImageMaxSize safely sets the Configuration value for state's 'MediaImageMaxSize' field 986 func (st *ConfigState) SetMediaImageMaxSize(v bytesize.Size) { 987 st.mutex.Lock() 988 defer st.mutex.Unlock() 989 st.config.MediaImageMaxSize = v 990 st.reloadToViper() 991 } 992 993 // MediaImageMaxSizeFlag returns the flag name for the 'MediaImageMaxSize' field 994 func MediaImageMaxSizeFlag() string { return "media-image-max-size" } 995 996 // GetMediaImageMaxSize safely fetches the value for global configuration 'MediaImageMaxSize' field 997 func GetMediaImageMaxSize() bytesize.Size { return global.GetMediaImageMaxSize() } 998 999 // SetMediaImageMaxSize safely sets the value for global configuration 'MediaImageMaxSize' field 1000 func SetMediaImageMaxSize(v bytesize.Size) { global.SetMediaImageMaxSize(v) } 1001 1002 // GetMediaVideoMaxSize safely fetches the Configuration value for state's 'MediaVideoMaxSize' field 1003 func (st *ConfigState) GetMediaVideoMaxSize() (v bytesize.Size) { 1004 st.mutex.Lock() 1005 v = st.config.MediaVideoMaxSize 1006 st.mutex.Unlock() 1007 return 1008 } 1009 1010 // SetMediaVideoMaxSize safely sets the Configuration value for state's 'MediaVideoMaxSize' field 1011 func (st *ConfigState) SetMediaVideoMaxSize(v bytesize.Size) { 1012 st.mutex.Lock() 1013 defer st.mutex.Unlock() 1014 st.config.MediaVideoMaxSize = v 1015 st.reloadToViper() 1016 } 1017 1018 // MediaVideoMaxSizeFlag returns the flag name for the 'MediaVideoMaxSize' field 1019 func MediaVideoMaxSizeFlag() string { return "media-video-max-size" } 1020 1021 // GetMediaVideoMaxSize safely fetches the value for global configuration 'MediaVideoMaxSize' field 1022 func GetMediaVideoMaxSize() bytesize.Size { return global.GetMediaVideoMaxSize() } 1023 1024 // SetMediaVideoMaxSize safely sets the value for global configuration 'MediaVideoMaxSize' field 1025 func SetMediaVideoMaxSize(v bytesize.Size) { global.SetMediaVideoMaxSize(v) } 1026 1027 // GetMediaDescriptionMinChars safely fetches the Configuration value for state's 'MediaDescriptionMinChars' field 1028 func (st *ConfigState) GetMediaDescriptionMinChars() (v int) { 1029 st.mutex.Lock() 1030 v = st.config.MediaDescriptionMinChars 1031 st.mutex.Unlock() 1032 return 1033 } 1034 1035 // SetMediaDescriptionMinChars safely sets the Configuration value for state's 'MediaDescriptionMinChars' field 1036 func (st *ConfigState) SetMediaDescriptionMinChars(v int) { 1037 st.mutex.Lock() 1038 defer st.mutex.Unlock() 1039 st.config.MediaDescriptionMinChars = v 1040 st.reloadToViper() 1041 } 1042 1043 // MediaDescriptionMinCharsFlag returns the flag name for the 'MediaDescriptionMinChars' field 1044 func MediaDescriptionMinCharsFlag() string { return "media-description-min-chars" } 1045 1046 // GetMediaDescriptionMinChars safely fetches the value for global configuration 'MediaDescriptionMinChars' field 1047 func GetMediaDescriptionMinChars() int { return global.GetMediaDescriptionMinChars() } 1048 1049 // SetMediaDescriptionMinChars safely sets the value for global configuration 'MediaDescriptionMinChars' field 1050 func SetMediaDescriptionMinChars(v int) { global.SetMediaDescriptionMinChars(v) } 1051 1052 // GetMediaDescriptionMaxChars safely fetches the Configuration value for state's 'MediaDescriptionMaxChars' field 1053 func (st *ConfigState) GetMediaDescriptionMaxChars() (v int) { 1054 st.mutex.Lock() 1055 v = st.config.MediaDescriptionMaxChars 1056 st.mutex.Unlock() 1057 return 1058 } 1059 1060 // SetMediaDescriptionMaxChars safely sets the Configuration value for state's 'MediaDescriptionMaxChars' field 1061 func (st *ConfigState) SetMediaDescriptionMaxChars(v int) { 1062 st.mutex.Lock() 1063 defer st.mutex.Unlock() 1064 st.config.MediaDescriptionMaxChars = v 1065 st.reloadToViper() 1066 } 1067 1068 // MediaDescriptionMaxCharsFlag returns the flag name for the 'MediaDescriptionMaxChars' field 1069 func MediaDescriptionMaxCharsFlag() string { return "media-description-max-chars" } 1070 1071 // GetMediaDescriptionMaxChars safely fetches the value for global configuration 'MediaDescriptionMaxChars' field 1072 func GetMediaDescriptionMaxChars() int { return global.GetMediaDescriptionMaxChars() } 1073 1074 // SetMediaDescriptionMaxChars safely sets the value for global configuration 'MediaDescriptionMaxChars' field 1075 func SetMediaDescriptionMaxChars(v int) { global.SetMediaDescriptionMaxChars(v) } 1076 1077 // GetMediaRemoteCacheDays safely fetches the Configuration value for state's 'MediaRemoteCacheDays' field 1078 func (st *ConfigState) GetMediaRemoteCacheDays() (v int) { 1079 st.mutex.Lock() 1080 v = st.config.MediaRemoteCacheDays 1081 st.mutex.Unlock() 1082 return 1083 } 1084 1085 // SetMediaRemoteCacheDays safely sets the Configuration value for state's 'MediaRemoteCacheDays' field 1086 func (st *ConfigState) SetMediaRemoteCacheDays(v int) { 1087 st.mutex.Lock() 1088 defer st.mutex.Unlock() 1089 st.config.MediaRemoteCacheDays = v 1090 st.reloadToViper() 1091 } 1092 1093 // MediaRemoteCacheDaysFlag returns the flag name for the 'MediaRemoteCacheDays' field 1094 func MediaRemoteCacheDaysFlag() string { return "media-remote-cache-days" } 1095 1096 // GetMediaRemoteCacheDays safely fetches the value for global configuration 'MediaRemoteCacheDays' field 1097 func GetMediaRemoteCacheDays() int { return global.GetMediaRemoteCacheDays() } 1098 1099 // SetMediaRemoteCacheDays safely sets the value for global configuration 'MediaRemoteCacheDays' field 1100 func SetMediaRemoteCacheDays(v int) { global.SetMediaRemoteCacheDays(v) } 1101 1102 // GetMediaEmojiLocalMaxSize safely fetches the Configuration value for state's 'MediaEmojiLocalMaxSize' field 1103 func (st *ConfigState) GetMediaEmojiLocalMaxSize() (v bytesize.Size) { 1104 st.mutex.Lock() 1105 v = st.config.MediaEmojiLocalMaxSize 1106 st.mutex.Unlock() 1107 return 1108 } 1109 1110 // SetMediaEmojiLocalMaxSize safely sets the Configuration value for state's 'MediaEmojiLocalMaxSize' field 1111 func (st *ConfigState) SetMediaEmojiLocalMaxSize(v bytesize.Size) { 1112 st.mutex.Lock() 1113 defer st.mutex.Unlock() 1114 st.config.MediaEmojiLocalMaxSize = v 1115 st.reloadToViper() 1116 } 1117 1118 // MediaEmojiLocalMaxSizeFlag returns the flag name for the 'MediaEmojiLocalMaxSize' field 1119 func MediaEmojiLocalMaxSizeFlag() string { return "media-emoji-local-max-size" } 1120 1121 // GetMediaEmojiLocalMaxSize safely fetches the value for global configuration 'MediaEmojiLocalMaxSize' field 1122 func GetMediaEmojiLocalMaxSize() bytesize.Size { return global.GetMediaEmojiLocalMaxSize() } 1123 1124 // SetMediaEmojiLocalMaxSize safely sets the value for global configuration 'MediaEmojiLocalMaxSize' field 1125 func SetMediaEmojiLocalMaxSize(v bytesize.Size) { global.SetMediaEmojiLocalMaxSize(v) } 1126 1127 // GetMediaEmojiRemoteMaxSize safely fetches the Configuration value for state's 'MediaEmojiRemoteMaxSize' field 1128 func (st *ConfigState) GetMediaEmojiRemoteMaxSize() (v bytesize.Size) { 1129 st.mutex.Lock() 1130 v = st.config.MediaEmojiRemoteMaxSize 1131 st.mutex.Unlock() 1132 return 1133 } 1134 1135 // SetMediaEmojiRemoteMaxSize safely sets the Configuration value for state's 'MediaEmojiRemoteMaxSize' field 1136 func (st *ConfigState) SetMediaEmojiRemoteMaxSize(v bytesize.Size) { 1137 st.mutex.Lock() 1138 defer st.mutex.Unlock() 1139 st.config.MediaEmojiRemoteMaxSize = v 1140 st.reloadToViper() 1141 } 1142 1143 // MediaEmojiRemoteMaxSizeFlag returns the flag name for the 'MediaEmojiRemoteMaxSize' field 1144 func MediaEmojiRemoteMaxSizeFlag() string { return "media-emoji-remote-max-size" } 1145 1146 // GetMediaEmojiRemoteMaxSize safely fetches the value for global configuration 'MediaEmojiRemoteMaxSize' field 1147 func GetMediaEmojiRemoteMaxSize() bytesize.Size { return global.GetMediaEmojiRemoteMaxSize() } 1148 1149 // SetMediaEmojiRemoteMaxSize safely sets the value for global configuration 'MediaEmojiRemoteMaxSize' field 1150 func SetMediaEmojiRemoteMaxSize(v bytesize.Size) { global.SetMediaEmojiRemoteMaxSize(v) } 1151 1152 // GetStorageBackend safely fetches the Configuration value for state's 'StorageBackend' field 1153 func (st *ConfigState) GetStorageBackend() (v string) { 1154 st.mutex.Lock() 1155 v = st.config.StorageBackend 1156 st.mutex.Unlock() 1157 return 1158 } 1159 1160 // SetStorageBackend safely sets the Configuration value for state's 'StorageBackend' field 1161 func (st *ConfigState) SetStorageBackend(v string) { 1162 st.mutex.Lock() 1163 defer st.mutex.Unlock() 1164 st.config.StorageBackend = v 1165 st.reloadToViper() 1166 } 1167 1168 // StorageBackendFlag returns the flag name for the 'StorageBackend' field 1169 func StorageBackendFlag() string { return "storage-backend" } 1170 1171 // GetStorageBackend safely fetches the value for global configuration 'StorageBackend' field 1172 func GetStorageBackend() string { return global.GetStorageBackend() } 1173 1174 // SetStorageBackend safely sets the value for global configuration 'StorageBackend' field 1175 func SetStorageBackend(v string) { global.SetStorageBackend(v) } 1176 1177 // GetStorageLocalBasePath safely fetches the Configuration value for state's 'StorageLocalBasePath' field 1178 func (st *ConfigState) GetStorageLocalBasePath() (v string) { 1179 st.mutex.Lock() 1180 v = st.config.StorageLocalBasePath 1181 st.mutex.Unlock() 1182 return 1183 } 1184 1185 // SetStorageLocalBasePath safely sets the Configuration value for state's 'StorageLocalBasePath' field 1186 func (st *ConfigState) SetStorageLocalBasePath(v string) { 1187 st.mutex.Lock() 1188 defer st.mutex.Unlock() 1189 st.config.StorageLocalBasePath = v 1190 st.reloadToViper() 1191 } 1192 1193 // StorageLocalBasePathFlag returns the flag name for the 'StorageLocalBasePath' field 1194 func StorageLocalBasePathFlag() string { return "storage-local-base-path" } 1195 1196 // GetStorageLocalBasePath safely fetches the value for global configuration 'StorageLocalBasePath' field 1197 func GetStorageLocalBasePath() string { return global.GetStorageLocalBasePath() } 1198 1199 // SetStorageLocalBasePath safely sets the value for global configuration 'StorageLocalBasePath' field 1200 func SetStorageLocalBasePath(v string) { global.SetStorageLocalBasePath(v) } 1201 1202 // GetStorageS3Endpoint safely fetches the Configuration value for state's 'StorageS3Endpoint' field 1203 func (st *ConfigState) GetStorageS3Endpoint() (v string) { 1204 st.mutex.Lock() 1205 v = st.config.StorageS3Endpoint 1206 st.mutex.Unlock() 1207 return 1208 } 1209 1210 // SetStorageS3Endpoint safely sets the Configuration value for state's 'StorageS3Endpoint' field 1211 func (st *ConfigState) SetStorageS3Endpoint(v string) { 1212 st.mutex.Lock() 1213 defer st.mutex.Unlock() 1214 st.config.StorageS3Endpoint = v 1215 st.reloadToViper() 1216 } 1217 1218 // StorageS3EndpointFlag returns the flag name for the 'StorageS3Endpoint' field 1219 func StorageS3EndpointFlag() string { return "storage-s3-endpoint" } 1220 1221 // GetStorageS3Endpoint safely fetches the value for global configuration 'StorageS3Endpoint' field 1222 func GetStorageS3Endpoint() string { return global.GetStorageS3Endpoint() } 1223 1224 // SetStorageS3Endpoint safely sets the value for global configuration 'StorageS3Endpoint' field 1225 func SetStorageS3Endpoint(v string) { global.SetStorageS3Endpoint(v) } 1226 1227 // GetStorageS3AccessKey safely fetches the Configuration value for state's 'StorageS3AccessKey' field 1228 func (st *ConfigState) GetStorageS3AccessKey() (v string) { 1229 st.mutex.Lock() 1230 v = st.config.StorageS3AccessKey 1231 st.mutex.Unlock() 1232 return 1233 } 1234 1235 // SetStorageS3AccessKey safely sets the Configuration value for state's 'StorageS3AccessKey' field 1236 func (st *ConfigState) SetStorageS3AccessKey(v string) { 1237 st.mutex.Lock() 1238 defer st.mutex.Unlock() 1239 st.config.StorageS3AccessKey = v 1240 st.reloadToViper() 1241 } 1242 1243 // StorageS3AccessKeyFlag returns the flag name for the 'StorageS3AccessKey' field 1244 func StorageS3AccessKeyFlag() string { return "storage-s3-access-key" } 1245 1246 // GetStorageS3AccessKey safely fetches the value for global configuration 'StorageS3AccessKey' field 1247 func GetStorageS3AccessKey() string { return global.GetStorageS3AccessKey() } 1248 1249 // SetStorageS3AccessKey safely sets the value for global configuration 'StorageS3AccessKey' field 1250 func SetStorageS3AccessKey(v string) { global.SetStorageS3AccessKey(v) } 1251 1252 // GetStorageS3SecretKey safely fetches the Configuration value for state's 'StorageS3SecretKey' field 1253 func (st *ConfigState) GetStorageS3SecretKey() (v string) { 1254 st.mutex.Lock() 1255 v = st.config.StorageS3SecretKey 1256 st.mutex.Unlock() 1257 return 1258 } 1259 1260 // SetStorageS3SecretKey safely sets the Configuration value for state's 'StorageS3SecretKey' field 1261 func (st *ConfigState) SetStorageS3SecretKey(v string) { 1262 st.mutex.Lock() 1263 defer st.mutex.Unlock() 1264 st.config.StorageS3SecretKey = v 1265 st.reloadToViper() 1266 } 1267 1268 // StorageS3SecretKeyFlag returns the flag name for the 'StorageS3SecretKey' field 1269 func StorageS3SecretKeyFlag() string { return "storage-s3-secret-key" } 1270 1271 // GetStorageS3SecretKey safely fetches the value for global configuration 'StorageS3SecretKey' field 1272 func GetStorageS3SecretKey() string { return global.GetStorageS3SecretKey() } 1273 1274 // SetStorageS3SecretKey safely sets the value for global configuration 'StorageS3SecretKey' field 1275 func SetStorageS3SecretKey(v string) { global.SetStorageS3SecretKey(v) } 1276 1277 // GetStorageS3UseSSL safely fetches the Configuration value for state's 'StorageS3UseSSL' field 1278 func (st *ConfigState) GetStorageS3UseSSL() (v bool) { 1279 st.mutex.Lock() 1280 v = st.config.StorageS3UseSSL 1281 st.mutex.Unlock() 1282 return 1283 } 1284 1285 // SetStorageS3UseSSL safely sets the Configuration value for state's 'StorageS3UseSSL' field 1286 func (st *ConfigState) SetStorageS3UseSSL(v bool) { 1287 st.mutex.Lock() 1288 defer st.mutex.Unlock() 1289 st.config.StorageS3UseSSL = v 1290 st.reloadToViper() 1291 } 1292 1293 // StorageS3UseSSLFlag returns the flag name for the 'StorageS3UseSSL' field 1294 func StorageS3UseSSLFlag() string { return "storage-s3-use-ssl" } 1295 1296 // GetStorageS3UseSSL safely fetches the value for global configuration 'StorageS3UseSSL' field 1297 func GetStorageS3UseSSL() bool { return global.GetStorageS3UseSSL() } 1298 1299 // SetStorageS3UseSSL safely sets the value for global configuration 'StorageS3UseSSL' field 1300 func SetStorageS3UseSSL(v bool) { global.SetStorageS3UseSSL(v) } 1301 1302 // GetStorageS3BucketName safely fetches the Configuration value for state's 'StorageS3BucketName' field 1303 func (st *ConfigState) GetStorageS3BucketName() (v string) { 1304 st.mutex.Lock() 1305 v = st.config.StorageS3BucketName 1306 st.mutex.Unlock() 1307 return 1308 } 1309 1310 // SetStorageS3BucketName safely sets the Configuration value for state's 'StorageS3BucketName' field 1311 func (st *ConfigState) SetStorageS3BucketName(v string) { 1312 st.mutex.Lock() 1313 defer st.mutex.Unlock() 1314 st.config.StorageS3BucketName = v 1315 st.reloadToViper() 1316 } 1317 1318 // StorageS3BucketNameFlag returns the flag name for the 'StorageS3BucketName' field 1319 func StorageS3BucketNameFlag() string { return "storage-s3-bucket" } 1320 1321 // GetStorageS3BucketName safely fetches the value for global configuration 'StorageS3BucketName' field 1322 func GetStorageS3BucketName() string { return global.GetStorageS3BucketName() } 1323 1324 // SetStorageS3BucketName safely sets the value for global configuration 'StorageS3BucketName' field 1325 func SetStorageS3BucketName(v string) { global.SetStorageS3BucketName(v) } 1326 1327 // GetStorageS3Proxy safely fetches the Configuration value for state's 'StorageS3Proxy' field 1328 func (st *ConfigState) GetStorageS3Proxy() (v bool) { 1329 st.mutex.Lock() 1330 v = st.config.StorageS3Proxy 1331 st.mutex.Unlock() 1332 return 1333 } 1334 1335 // SetStorageS3Proxy safely sets the Configuration value for state's 'StorageS3Proxy' field 1336 func (st *ConfigState) SetStorageS3Proxy(v bool) { 1337 st.mutex.Lock() 1338 defer st.mutex.Unlock() 1339 st.config.StorageS3Proxy = v 1340 st.reloadToViper() 1341 } 1342 1343 // StorageS3ProxyFlag returns the flag name for the 'StorageS3Proxy' field 1344 func StorageS3ProxyFlag() string { return "storage-s3-proxy" } 1345 1346 // GetStorageS3Proxy safely fetches the value for global configuration 'StorageS3Proxy' field 1347 func GetStorageS3Proxy() bool { return global.GetStorageS3Proxy() } 1348 1349 // SetStorageS3Proxy safely sets the value for global configuration 'StorageS3Proxy' field 1350 func SetStorageS3Proxy(v bool) { global.SetStorageS3Proxy(v) } 1351 1352 // GetStatusesMaxChars safely fetches the Configuration value for state's 'StatusesMaxChars' field 1353 func (st *ConfigState) GetStatusesMaxChars() (v int) { 1354 st.mutex.Lock() 1355 v = st.config.StatusesMaxChars 1356 st.mutex.Unlock() 1357 return 1358 } 1359 1360 // SetStatusesMaxChars safely sets the Configuration value for state's 'StatusesMaxChars' field 1361 func (st *ConfigState) SetStatusesMaxChars(v int) { 1362 st.mutex.Lock() 1363 defer st.mutex.Unlock() 1364 st.config.StatusesMaxChars = v 1365 st.reloadToViper() 1366 } 1367 1368 // StatusesMaxCharsFlag returns the flag name for the 'StatusesMaxChars' field 1369 func StatusesMaxCharsFlag() string { return "statuses-max-chars" } 1370 1371 // GetStatusesMaxChars safely fetches the value for global configuration 'StatusesMaxChars' field 1372 func GetStatusesMaxChars() int { return global.GetStatusesMaxChars() } 1373 1374 // SetStatusesMaxChars safely sets the value for global configuration 'StatusesMaxChars' field 1375 func SetStatusesMaxChars(v int) { global.SetStatusesMaxChars(v) } 1376 1377 // GetStatusesCWMaxChars safely fetches the Configuration value for state's 'StatusesCWMaxChars' field 1378 func (st *ConfigState) GetStatusesCWMaxChars() (v int) { 1379 st.mutex.Lock() 1380 v = st.config.StatusesCWMaxChars 1381 st.mutex.Unlock() 1382 return 1383 } 1384 1385 // SetStatusesCWMaxChars safely sets the Configuration value for state's 'StatusesCWMaxChars' field 1386 func (st *ConfigState) SetStatusesCWMaxChars(v int) { 1387 st.mutex.Lock() 1388 defer st.mutex.Unlock() 1389 st.config.StatusesCWMaxChars = v 1390 st.reloadToViper() 1391 } 1392 1393 // StatusesCWMaxCharsFlag returns the flag name for the 'StatusesCWMaxChars' field 1394 func StatusesCWMaxCharsFlag() string { return "statuses-cw-max-chars" } 1395 1396 // GetStatusesCWMaxChars safely fetches the value for global configuration 'StatusesCWMaxChars' field 1397 func GetStatusesCWMaxChars() int { return global.GetStatusesCWMaxChars() } 1398 1399 // SetStatusesCWMaxChars safely sets the value for global configuration 'StatusesCWMaxChars' field 1400 func SetStatusesCWMaxChars(v int) { global.SetStatusesCWMaxChars(v) } 1401 1402 // GetStatusesPollMaxOptions safely fetches the Configuration value for state's 'StatusesPollMaxOptions' field 1403 func (st *ConfigState) GetStatusesPollMaxOptions() (v int) { 1404 st.mutex.Lock() 1405 v = st.config.StatusesPollMaxOptions 1406 st.mutex.Unlock() 1407 return 1408 } 1409 1410 // SetStatusesPollMaxOptions safely sets the Configuration value for state's 'StatusesPollMaxOptions' field 1411 func (st *ConfigState) SetStatusesPollMaxOptions(v int) { 1412 st.mutex.Lock() 1413 defer st.mutex.Unlock() 1414 st.config.StatusesPollMaxOptions = v 1415 st.reloadToViper() 1416 } 1417 1418 // StatusesPollMaxOptionsFlag returns the flag name for the 'StatusesPollMaxOptions' field 1419 func StatusesPollMaxOptionsFlag() string { return "statuses-poll-max-options" } 1420 1421 // GetStatusesPollMaxOptions safely fetches the value for global configuration 'StatusesPollMaxOptions' field 1422 func GetStatusesPollMaxOptions() int { return global.GetStatusesPollMaxOptions() } 1423 1424 // SetStatusesPollMaxOptions safely sets the value for global configuration 'StatusesPollMaxOptions' field 1425 func SetStatusesPollMaxOptions(v int) { global.SetStatusesPollMaxOptions(v) } 1426 1427 // GetStatusesPollOptionMaxChars safely fetches the Configuration value for state's 'StatusesPollOptionMaxChars' field 1428 func (st *ConfigState) GetStatusesPollOptionMaxChars() (v int) { 1429 st.mutex.Lock() 1430 v = st.config.StatusesPollOptionMaxChars 1431 st.mutex.Unlock() 1432 return 1433 } 1434 1435 // SetStatusesPollOptionMaxChars safely sets the Configuration value for state's 'StatusesPollOptionMaxChars' field 1436 func (st *ConfigState) SetStatusesPollOptionMaxChars(v int) { 1437 st.mutex.Lock() 1438 defer st.mutex.Unlock() 1439 st.config.StatusesPollOptionMaxChars = v 1440 st.reloadToViper() 1441 } 1442 1443 // StatusesPollOptionMaxCharsFlag returns the flag name for the 'StatusesPollOptionMaxChars' field 1444 func StatusesPollOptionMaxCharsFlag() string { return "statuses-poll-option-max-chars" } 1445 1446 // GetStatusesPollOptionMaxChars safely fetches the value for global configuration 'StatusesPollOptionMaxChars' field 1447 func GetStatusesPollOptionMaxChars() int { return global.GetStatusesPollOptionMaxChars() } 1448 1449 // SetStatusesPollOptionMaxChars safely sets the value for global configuration 'StatusesPollOptionMaxChars' field 1450 func SetStatusesPollOptionMaxChars(v int) { global.SetStatusesPollOptionMaxChars(v) } 1451 1452 // GetStatusesMediaMaxFiles safely fetches the Configuration value for state's 'StatusesMediaMaxFiles' field 1453 func (st *ConfigState) GetStatusesMediaMaxFiles() (v int) { 1454 st.mutex.Lock() 1455 v = st.config.StatusesMediaMaxFiles 1456 st.mutex.Unlock() 1457 return 1458 } 1459 1460 // SetStatusesMediaMaxFiles safely sets the Configuration value for state's 'StatusesMediaMaxFiles' field 1461 func (st *ConfigState) SetStatusesMediaMaxFiles(v int) { 1462 st.mutex.Lock() 1463 defer st.mutex.Unlock() 1464 st.config.StatusesMediaMaxFiles = v 1465 st.reloadToViper() 1466 } 1467 1468 // StatusesMediaMaxFilesFlag returns the flag name for the 'StatusesMediaMaxFiles' field 1469 func StatusesMediaMaxFilesFlag() string { return "statuses-media-max-files" } 1470 1471 // GetStatusesMediaMaxFiles safely fetches the value for global configuration 'StatusesMediaMaxFiles' field 1472 func GetStatusesMediaMaxFiles() int { return global.GetStatusesMediaMaxFiles() } 1473 1474 // SetStatusesMediaMaxFiles safely sets the value for global configuration 'StatusesMediaMaxFiles' field 1475 func SetStatusesMediaMaxFiles(v int) { global.SetStatusesMediaMaxFiles(v) } 1476 1477 // GetLetsEncryptEnabled safely fetches the Configuration value for state's 'LetsEncryptEnabled' field 1478 func (st *ConfigState) GetLetsEncryptEnabled() (v bool) { 1479 st.mutex.Lock() 1480 v = st.config.LetsEncryptEnabled 1481 st.mutex.Unlock() 1482 return 1483 } 1484 1485 // SetLetsEncryptEnabled safely sets the Configuration value for state's 'LetsEncryptEnabled' field 1486 func (st *ConfigState) SetLetsEncryptEnabled(v bool) { 1487 st.mutex.Lock() 1488 defer st.mutex.Unlock() 1489 st.config.LetsEncryptEnabled = v 1490 st.reloadToViper() 1491 } 1492 1493 // LetsEncryptEnabledFlag returns the flag name for the 'LetsEncryptEnabled' field 1494 func LetsEncryptEnabledFlag() string { return "letsencrypt-enabled" } 1495 1496 // GetLetsEncryptEnabled safely fetches the value for global configuration 'LetsEncryptEnabled' field 1497 func GetLetsEncryptEnabled() bool { return global.GetLetsEncryptEnabled() } 1498 1499 // SetLetsEncryptEnabled safely sets the value for global configuration 'LetsEncryptEnabled' field 1500 func SetLetsEncryptEnabled(v bool) { global.SetLetsEncryptEnabled(v) } 1501 1502 // GetLetsEncryptPort safely fetches the Configuration value for state's 'LetsEncryptPort' field 1503 func (st *ConfigState) GetLetsEncryptPort() (v int) { 1504 st.mutex.Lock() 1505 v = st.config.LetsEncryptPort 1506 st.mutex.Unlock() 1507 return 1508 } 1509 1510 // SetLetsEncryptPort safely sets the Configuration value for state's 'LetsEncryptPort' field 1511 func (st *ConfigState) SetLetsEncryptPort(v int) { 1512 st.mutex.Lock() 1513 defer st.mutex.Unlock() 1514 st.config.LetsEncryptPort = v 1515 st.reloadToViper() 1516 } 1517 1518 // LetsEncryptPortFlag returns the flag name for the 'LetsEncryptPort' field 1519 func LetsEncryptPortFlag() string { return "letsencrypt-port" } 1520 1521 // GetLetsEncryptPort safely fetches the value for global configuration 'LetsEncryptPort' field 1522 func GetLetsEncryptPort() int { return global.GetLetsEncryptPort() } 1523 1524 // SetLetsEncryptPort safely sets the value for global configuration 'LetsEncryptPort' field 1525 func SetLetsEncryptPort(v int) { global.SetLetsEncryptPort(v) } 1526 1527 // GetLetsEncryptCertDir safely fetches the Configuration value for state's 'LetsEncryptCertDir' field 1528 func (st *ConfigState) GetLetsEncryptCertDir() (v string) { 1529 st.mutex.Lock() 1530 v = st.config.LetsEncryptCertDir 1531 st.mutex.Unlock() 1532 return 1533 } 1534 1535 // SetLetsEncryptCertDir safely sets the Configuration value for state's 'LetsEncryptCertDir' field 1536 func (st *ConfigState) SetLetsEncryptCertDir(v string) { 1537 st.mutex.Lock() 1538 defer st.mutex.Unlock() 1539 st.config.LetsEncryptCertDir = v 1540 st.reloadToViper() 1541 } 1542 1543 // LetsEncryptCertDirFlag returns the flag name for the 'LetsEncryptCertDir' field 1544 func LetsEncryptCertDirFlag() string { return "letsencrypt-cert-dir" } 1545 1546 // GetLetsEncryptCertDir safely fetches the value for global configuration 'LetsEncryptCertDir' field 1547 func GetLetsEncryptCertDir() string { return global.GetLetsEncryptCertDir() } 1548 1549 // SetLetsEncryptCertDir safely sets the value for global configuration 'LetsEncryptCertDir' field 1550 func SetLetsEncryptCertDir(v string) { global.SetLetsEncryptCertDir(v) } 1551 1552 // GetLetsEncryptEmailAddress safely fetches the Configuration value for state's 'LetsEncryptEmailAddress' field 1553 func (st *ConfigState) GetLetsEncryptEmailAddress() (v string) { 1554 st.mutex.Lock() 1555 v = st.config.LetsEncryptEmailAddress 1556 st.mutex.Unlock() 1557 return 1558 } 1559 1560 // SetLetsEncryptEmailAddress safely sets the Configuration value for state's 'LetsEncryptEmailAddress' field 1561 func (st *ConfigState) SetLetsEncryptEmailAddress(v string) { 1562 st.mutex.Lock() 1563 defer st.mutex.Unlock() 1564 st.config.LetsEncryptEmailAddress = v 1565 st.reloadToViper() 1566 } 1567 1568 // LetsEncryptEmailAddressFlag returns the flag name for the 'LetsEncryptEmailAddress' field 1569 func LetsEncryptEmailAddressFlag() string { return "letsencrypt-email-address" } 1570 1571 // GetLetsEncryptEmailAddress safely fetches the value for global configuration 'LetsEncryptEmailAddress' field 1572 func GetLetsEncryptEmailAddress() string { return global.GetLetsEncryptEmailAddress() } 1573 1574 // SetLetsEncryptEmailAddress safely sets the value for global configuration 'LetsEncryptEmailAddress' field 1575 func SetLetsEncryptEmailAddress(v string) { global.SetLetsEncryptEmailAddress(v) } 1576 1577 // GetTLSCertificateChain safely fetches the Configuration value for state's 'TLSCertificateChain' field 1578 func (st *ConfigState) GetTLSCertificateChain() (v string) { 1579 st.mutex.Lock() 1580 v = st.config.TLSCertificateChain 1581 st.mutex.Unlock() 1582 return 1583 } 1584 1585 // SetTLSCertificateChain safely sets the Configuration value for state's 'TLSCertificateChain' field 1586 func (st *ConfigState) SetTLSCertificateChain(v string) { 1587 st.mutex.Lock() 1588 defer st.mutex.Unlock() 1589 st.config.TLSCertificateChain = v 1590 st.reloadToViper() 1591 } 1592 1593 // TLSCertificateChainFlag returns the flag name for the 'TLSCertificateChain' field 1594 func TLSCertificateChainFlag() string { return "tls-certificate-chain" } 1595 1596 // GetTLSCertificateChain safely fetches the value for global configuration 'TLSCertificateChain' field 1597 func GetTLSCertificateChain() string { return global.GetTLSCertificateChain() } 1598 1599 // SetTLSCertificateChain safely sets the value for global configuration 'TLSCertificateChain' field 1600 func SetTLSCertificateChain(v string) { global.SetTLSCertificateChain(v) } 1601 1602 // GetTLSCertificateKey safely fetches the Configuration value for state's 'TLSCertificateKey' field 1603 func (st *ConfigState) GetTLSCertificateKey() (v string) { 1604 st.mutex.Lock() 1605 v = st.config.TLSCertificateKey 1606 st.mutex.Unlock() 1607 return 1608 } 1609 1610 // SetTLSCertificateKey safely sets the Configuration value for state's 'TLSCertificateKey' field 1611 func (st *ConfigState) SetTLSCertificateKey(v string) { 1612 st.mutex.Lock() 1613 defer st.mutex.Unlock() 1614 st.config.TLSCertificateKey = v 1615 st.reloadToViper() 1616 } 1617 1618 // TLSCertificateKeyFlag returns the flag name for the 'TLSCertificateKey' field 1619 func TLSCertificateKeyFlag() string { return "tls-certificate-key" } 1620 1621 // GetTLSCertificateKey safely fetches the value for global configuration 'TLSCertificateKey' field 1622 func GetTLSCertificateKey() string { return global.GetTLSCertificateKey() } 1623 1624 // SetTLSCertificateKey safely sets the value for global configuration 'TLSCertificateKey' field 1625 func SetTLSCertificateKey(v string) { global.SetTLSCertificateKey(v) } 1626 1627 // GetOIDCEnabled safely fetches the Configuration value for state's 'OIDCEnabled' field 1628 func (st *ConfigState) GetOIDCEnabled() (v bool) { 1629 st.mutex.Lock() 1630 v = st.config.OIDCEnabled 1631 st.mutex.Unlock() 1632 return 1633 } 1634 1635 // SetOIDCEnabled safely sets the Configuration value for state's 'OIDCEnabled' field 1636 func (st *ConfigState) SetOIDCEnabled(v bool) { 1637 st.mutex.Lock() 1638 defer st.mutex.Unlock() 1639 st.config.OIDCEnabled = v 1640 st.reloadToViper() 1641 } 1642 1643 // OIDCEnabledFlag returns the flag name for the 'OIDCEnabled' field 1644 func OIDCEnabledFlag() string { return "oidc-enabled" } 1645 1646 // GetOIDCEnabled safely fetches the value for global configuration 'OIDCEnabled' field 1647 func GetOIDCEnabled() bool { return global.GetOIDCEnabled() } 1648 1649 // SetOIDCEnabled safely sets the value for global configuration 'OIDCEnabled' field 1650 func SetOIDCEnabled(v bool) { global.SetOIDCEnabled(v) } 1651 1652 // GetOIDCIdpName safely fetches the Configuration value for state's 'OIDCIdpName' field 1653 func (st *ConfigState) GetOIDCIdpName() (v string) { 1654 st.mutex.Lock() 1655 v = st.config.OIDCIdpName 1656 st.mutex.Unlock() 1657 return 1658 } 1659 1660 // SetOIDCIdpName safely sets the Configuration value for state's 'OIDCIdpName' field 1661 func (st *ConfigState) SetOIDCIdpName(v string) { 1662 st.mutex.Lock() 1663 defer st.mutex.Unlock() 1664 st.config.OIDCIdpName = v 1665 st.reloadToViper() 1666 } 1667 1668 // OIDCIdpNameFlag returns the flag name for the 'OIDCIdpName' field 1669 func OIDCIdpNameFlag() string { return "oidc-idp-name" } 1670 1671 // GetOIDCIdpName safely fetches the value for global configuration 'OIDCIdpName' field 1672 func GetOIDCIdpName() string { return global.GetOIDCIdpName() } 1673 1674 // SetOIDCIdpName safely sets the value for global configuration 'OIDCIdpName' field 1675 func SetOIDCIdpName(v string) { global.SetOIDCIdpName(v) } 1676 1677 // GetOIDCSkipVerification safely fetches the Configuration value for state's 'OIDCSkipVerification' field 1678 func (st *ConfigState) GetOIDCSkipVerification() (v bool) { 1679 st.mutex.Lock() 1680 v = st.config.OIDCSkipVerification 1681 st.mutex.Unlock() 1682 return 1683 } 1684 1685 // SetOIDCSkipVerification safely sets the Configuration value for state's 'OIDCSkipVerification' field 1686 func (st *ConfigState) SetOIDCSkipVerification(v bool) { 1687 st.mutex.Lock() 1688 defer st.mutex.Unlock() 1689 st.config.OIDCSkipVerification = v 1690 st.reloadToViper() 1691 } 1692 1693 // OIDCSkipVerificationFlag returns the flag name for the 'OIDCSkipVerification' field 1694 func OIDCSkipVerificationFlag() string { return "oidc-skip-verification" } 1695 1696 // GetOIDCSkipVerification safely fetches the value for global configuration 'OIDCSkipVerification' field 1697 func GetOIDCSkipVerification() bool { return global.GetOIDCSkipVerification() } 1698 1699 // SetOIDCSkipVerification safely sets the value for global configuration 'OIDCSkipVerification' field 1700 func SetOIDCSkipVerification(v bool) { global.SetOIDCSkipVerification(v) } 1701 1702 // GetOIDCIssuer safely fetches the Configuration value for state's 'OIDCIssuer' field 1703 func (st *ConfigState) GetOIDCIssuer() (v string) { 1704 st.mutex.Lock() 1705 v = st.config.OIDCIssuer 1706 st.mutex.Unlock() 1707 return 1708 } 1709 1710 // SetOIDCIssuer safely sets the Configuration value for state's 'OIDCIssuer' field 1711 func (st *ConfigState) SetOIDCIssuer(v string) { 1712 st.mutex.Lock() 1713 defer st.mutex.Unlock() 1714 st.config.OIDCIssuer = v 1715 st.reloadToViper() 1716 } 1717 1718 // OIDCIssuerFlag returns the flag name for the 'OIDCIssuer' field 1719 func OIDCIssuerFlag() string { return "oidc-issuer" } 1720 1721 // GetOIDCIssuer safely fetches the value for global configuration 'OIDCIssuer' field 1722 func GetOIDCIssuer() string { return global.GetOIDCIssuer() } 1723 1724 // SetOIDCIssuer safely sets the value for global configuration 'OIDCIssuer' field 1725 func SetOIDCIssuer(v string) { global.SetOIDCIssuer(v) } 1726 1727 // GetOIDCClientID safely fetches the Configuration value for state's 'OIDCClientID' field 1728 func (st *ConfigState) GetOIDCClientID() (v string) { 1729 st.mutex.Lock() 1730 v = st.config.OIDCClientID 1731 st.mutex.Unlock() 1732 return 1733 } 1734 1735 // SetOIDCClientID safely sets the Configuration value for state's 'OIDCClientID' field 1736 func (st *ConfigState) SetOIDCClientID(v string) { 1737 st.mutex.Lock() 1738 defer st.mutex.Unlock() 1739 st.config.OIDCClientID = v 1740 st.reloadToViper() 1741 } 1742 1743 // OIDCClientIDFlag returns the flag name for the 'OIDCClientID' field 1744 func OIDCClientIDFlag() string { return "oidc-client-id" } 1745 1746 // GetOIDCClientID safely fetches the value for global configuration 'OIDCClientID' field 1747 func GetOIDCClientID() string { return global.GetOIDCClientID() } 1748 1749 // SetOIDCClientID safely sets the value for global configuration 'OIDCClientID' field 1750 func SetOIDCClientID(v string) { global.SetOIDCClientID(v) } 1751 1752 // GetOIDCClientSecret safely fetches the Configuration value for state's 'OIDCClientSecret' field 1753 func (st *ConfigState) GetOIDCClientSecret() (v string) { 1754 st.mutex.Lock() 1755 v = st.config.OIDCClientSecret 1756 st.mutex.Unlock() 1757 return 1758 } 1759 1760 // SetOIDCClientSecret safely sets the Configuration value for state's 'OIDCClientSecret' field 1761 func (st *ConfigState) SetOIDCClientSecret(v string) { 1762 st.mutex.Lock() 1763 defer st.mutex.Unlock() 1764 st.config.OIDCClientSecret = v 1765 st.reloadToViper() 1766 } 1767 1768 // OIDCClientSecretFlag returns the flag name for the 'OIDCClientSecret' field 1769 func OIDCClientSecretFlag() string { return "oidc-client-secret" } 1770 1771 // GetOIDCClientSecret safely fetches the value for global configuration 'OIDCClientSecret' field 1772 func GetOIDCClientSecret() string { return global.GetOIDCClientSecret() } 1773 1774 // SetOIDCClientSecret safely sets the value for global configuration 'OIDCClientSecret' field 1775 func SetOIDCClientSecret(v string) { global.SetOIDCClientSecret(v) } 1776 1777 // GetOIDCScopes safely fetches the Configuration value for state's 'OIDCScopes' field 1778 func (st *ConfigState) GetOIDCScopes() (v []string) { 1779 st.mutex.Lock() 1780 v = st.config.OIDCScopes 1781 st.mutex.Unlock() 1782 return 1783 } 1784 1785 // SetOIDCScopes safely sets the Configuration value for state's 'OIDCScopes' field 1786 func (st *ConfigState) SetOIDCScopes(v []string) { 1787 st.mutex.Lock() 1788 defer st.mutex.Unlock() 1789 st.config.OIDCScopes = v 1790 st.reloadToViper() 1791 } 1792 1793 // OIDCScopesFlag returns the flag name for the 'OIDCScopes' field 1794 func OIDCScopesFlag() string { return "oidc-scopes" } 1795 1796 // GetOIDCScopes safely fetches the value for global configuration 'OIDCScopes' field 1797 func GetOIDCScopes() []string { return global.GetOIDCScopes() } 1798 1799 // SetOIDCScopes safely sets the value for global configuration 'OIDCScopes' field 1800 func SetOIDCScopes(v []string) { global.SetOIDCScopes(v) } 1801 1802 // GetOIDCLinkExisting safely fetches the Configuration value for state's 'OIDCLinkExisting' field 1803 func (st *ConfigState) GetOIDCLinkExisting() (v bool) { 1804 st.mutex.Lock() 1805 v = st.config.OIDCLinkExisting 1806 st.mutex.Unlock() 1807 return 1808 } 1809 1810 // SetOIDCLinkExisting safely sets the Configuration value for state's 'OIDCLinkExisting' field 1811 func (st *ConfigState) SetOIDCLinkExisting(v bool) { 1812 st.mutex.Lock() 1813 defer st.mutex.Unlock() 1814 st.config.OIDCLinkExisting = v 1815 st.reloadToViper() 1816 } 1817 1818 // OIDCLinkExistingFlag returns the flag name for the 'OIDCLinkExisting' field 1819 func OIDCLinkExistingFlag() string { return "oidc-link-existing" } 1820 1821 // GetOIDCLinkExisting safely fetches the value for global configuration 'OIDCLinkExisting' field 1822 func GetOIDCLinkExisting() bool { return global.GetOIDCLinkExisting() } 1823 1824 // SetOIDCLinkExisting safely sets the value for global configuration 'OIDCLinkExisting' field 1825 func SetOIDCLinkExisting(v bool) { global.SetOIDCLinkExisting(v) } 1826 1827 // GetOIDCAdminGroups safely fetches the Configuration value for state's 'OIDCAdminGroups' field 1828 func (st *ConfigState) GetOIDCAdminGroups() (v []string) { 1829 st.mutex.Lock() 1830 v = st.config.OIDCAdminGroups 1831 st.mutex.Unlock() 1832 return 1833 } 1834 1835 // SetOIDCAdminGroups safely sets the Configuration value for state's 'OIDCAdminGroups' field 1836 func (st *ConfigState) SetOIDCAdminGroups(v []string) { 1837 st.mutex.Lock() 1838 defer st.mutex.Unlock() 1839 st.config.OIDCAdminGroups = v 1840 st.reloadToViper() 1841 } 1842 1843 // OIDCAdminGroupsFlag returns the flag name for the 'OIDCAdminGroups' field 1844 func OIDCAdminGroupsFlag() string { return "oidc-admin-groups" } 1845 1846 // GetOIDCAdminGroups safely fetches the value for global configuration 'OIDCAdminGroups' field 1847 func GetOIDCAdminGroups() []string { return global.GetOIDCAdminGroups() } 1848 1849 // SetOIDCAdminGroups safely sets the value for global configuration 'OIDCAdminGroups' field 1850 func SetOIDCAdminGroups(v []string) { global.SetOIDCAdminGroups(v) } 1851 1852 // GetTracingEnabled safely fetches the Configuration value for state's 'TracingEnabled' field 1853 func (st *ConfigState) GetTracingEnabled() (v bool) { 1854 st.mutex.Lock() 1855 v = st.config.TracingEnabled 1856 st.mutex.Unlock() 1857 return 1858 } 1859 1860 // SetTracingEnabled safely sets the Configuration value for state's 'TracingEnabled' field 1861 func (st *ConfigState) SetTracingEnabled(v bool) { 1862 st.mutex.Lock() 1863 defer st.mutex.Unlock() 1864 st.config.TracingEnabled = v 1865 st.reloadToViper() 1866 } 1867 1868 // TracingEnabledFlag returns the flag name for the 'TracingEnabled' field 1869 func TracingEnabledFlag() string { return "tracing-enabled" } 1870 1871 // GetTracingEnabled safely fetches the value for global configuration 'TracingEnabled' field 1872 func GetTracingEnabled() bool { return global.GetTracingEnabled() } 1873 1874 // SetTracingEnabled safely sets the value for global configuration 'TracingEnabled' field 1875 func SetTracingEnabled(v bool) { global.SetTracingEnabled(v) } 1876 1877 // GetTracingTransport safely fetches the Configuration value for state's 'TracingTransport' field 1878 func (st *ConfigState) GetTracingTransport() (v string) { 1879 st.mutex.Lock() 1880 v = st.config.TracingTransport 1881 st.mutex.Unlock() 1882 return 1883 } 1884 1885 // SetTracingTransport safely sets the Configuration value for state's 'TracingTransport' field 1886 func (st *ConfigState) SetTracingTransport(v string) { 1887 st.mutex.Lock() 1888 defer st.mutex.Unlock() 1889 st.config.TracingTransport = v 1890 st.reloadToViper() 1891 } 1892 1893 // TracingTransportFlag returns the flag name for the 'TracingTransport' field 1894 func TracingTransportFlag() string { return "tracing-transport" } 1895 1896 // GetTracingTransport safely fetches the value for global configuration 'TracingTransport' field 1897 func GetTracingTransport() string { return global.GetTracingTransport() } 1898 1899 // SetTracingTransport safely sets the value for global configuration 'TracingTransport' field 1900 func SetTracingTransport(v string) { global.SetTracingTransport(v) } 1901 1902 // GetTracingEndpoint safely fetches the Configuration value for state's 'TracingEndpoint' field 1903 func (st *ConfigState) GetTracingEndpoint() (v string) { 1904 st.mutex.Lock() 1905 v = st.config.TracingEndpoint 1906 st.mutex.Unlock() 1907 return 1908 } 1909 1910 // SetTracingEndpoint safely sets the Configuration value for state's 'TracingEndpoint' field 1911 func (st *ConfigState) SetTracingEndpoint(v string) { 1912 st.mutex.Lock() 1913 defer st.mutex.Unlock() 1914 st.config.TracingEndpoint = v 1915 st.reloadToViper() 1916 } 1917 1918 // TracingEndpointFlag returns the flag name for the 'TracingEndpoint' field 1919 func TracingEndpointFlag() string { return "tracing-endpoint" } 1920 1921 // GetTracingEndpoint safely fetches the value for global configuration 'TracingEndpoint' field 1922 func GetTracingEndpoint() string { return global.GetTracingEndpoint() } 1923 1924 // SetTracingEndpoint safely sets the value for global configuration 'TracingEndpoint' field 1925 func SetTracingEndpoint(v string) { global.SetTracingEndpoint(v) } 1926 1927 // GetTracingInsecureTransport safely fetches the Configuration value for state's 'TracingInsecureTransport' field 1928 func (st *ConfigState) GetTracingInsecureTransport() (v bool) { 1929 st.mutex.Lock() 1930 v = st.config.TracingInsecureTransport 1931 st.mutex.Unlock() 1932 return 1933 } 1934 1935 // SetTracingInsecureTransport safely sets the Configuration value for state's 'TracingInsecureTransport' field 1936 func (st *ConfigState) SetTracingInsecureTransport(v bool) { 1937 st.mutex.Lock() 1938 defer st.mutex.Unlock() 1939 st.config.TracingInsecureTransport = v 1940 st.reloadToViper() 1941 } 1942 1943 // TracingInsecureTransportFlag returns the flag name for the 'TracingInsecureTransport' field 1944 func TracingInsecureTransportFlag() string { return "tracing-insecure" } 1945 1946 // GetTracingInsecureTransport safely fetches the value for global configuration 'TracingInsecureTransport' field 1947 func GetTracingInsecureTransport() bool { return global.GetTracingInsecureTransport() } 1948 1949 // SetTracingInsecureTransport safely sets the value for global configuration 'TracingInsecureTransport' field 1950 func SetTracingInsecureTransport(v bool) { global.SetTracingInsecureTransport(v) } 1951 1952 // GetSMTPHost safely fetches the Configuration value for state's 'SMTPHost' field 1953 func (st *ConfigState) GetSMTPHost() (v string) { 1954 st.mutex.Lock() 1955 v = st.config.SMTPHost 1956 st.mutex.Unlock() 1957 return 1958 } 1959 1960 // SetSMTPHost safely sets the Configuration value for state's 'SMTPHost' field 1961 func (st *ConfigState) SetSMTPHost(v string) { 1962 st.mutex.Lock() 1963 defer st.mutex.Unlock() 1964 st.config.SMTPHost = v 1965 st.reloadToViper() 1966 } 1967 1968 // SMTPHostFlag returns the flag name for the 'SMTPHost' field 1969 func SMTPHostFlag() string { return "smtp-host" } 1970 1971 // GetSMTPHost safely fetches the value for global configuration 'SMTPHost' field 1972 func GetSMTPHost() string { return global.GetSMTPHost() } 1973 1974 // SetSMTPHost safely sets the value for global configuration 'SMTPHost' field 1975 func SetSMTPHost(v string) { global.SetSMTPHost(v) } 1976 1977 // GetSMTPPort safely fetches the Configuration value for state's 'SMTPPort' field 1978 func (st *ConfigState) GetSMTPPort() (v int) { 1979 st.mutex.Lock() 1980 v = st.config.SMTPPort 1981 st.mutex.Unlock() 1982 return 1983 } 1984 1985 // SetSMTPPort safely sets the Configuration value for state's 'SMTPPort' field 1986 func (st *ConfigState) SetSMTPPort(v int) { 1987 st.mutex.Lock() 1988 defer st.mutex.Unlock() 1989 st.config.SMTPPort = v 1990 st.reloadToViper() 1991 } 1992 1993 // SMTPPortFlag returns the flag name for the 'SMTPPort' field 1994 func SMTPPortFlag() string { return "smtp-port" } 1995 1996 // GetSMTPPort safely fetches the value for global configuration 'SMTPPort' field 1997 func GetSMTPPort() int { return global.GetSMTPPort() } 1998 1999 // SetSMTPPort safely sets the value for global configuration 'SMTPPort' field 2000 func SetSMTPPort(v int) { global.SetSMTPPort(v) } 2001 2002 // GetSMTPUsername safely fetches the Configuration value for state's 'SMTPUsername' field 2003 func (st *ConfigState) GetSMTPUsername() (v string) { 2004 st.mutex.Lock() 2005 v = st.config.SMTPUsername 2006 st.mutex.Unlock() 2007 return 2008 } 2009 2010 // SetSMTPUsername safely sets the Configuration value for state's 'SMTPUsername' field 2011 func (st *ConfigState) SetSMTPUsername(v string) { 2012 st.mutex.Lock() 2013 defer st.mutex.Unlock() 2014 st.config.SMTPUsername = v 2015 st.reloadToViper() 2016 } 2017 2018 // SMTPUsernameFlag returns the flag name for the 'SMTPUsername' field 2019 func SMTPUsernameFlag() string { return "smtp-username" } 2020 2021 // GetSMTPUsername safely fetches the value for global configuration 'SMTPUsername' field 2022 func GetSMTPUsername() string { return global.GetSMTPUsername() } 2023 2024 // SetSMTPUsername safely sets the value for global configuration 'SMTPUsername' field 2025 func SetSMTPUsername(v string) { global.SetSMTPUsername(v) } 2026 2027 // GetSMTPPassword safely fetches the Configuration value for state's 'SMTPPassword' field 2028 func (st *ConfigState) GetSMTPPassword() (v string) { 2029 st.mutex.Lock() 2030 v = st.config.SMTPPassword 2031 st.mutex.Unlock() 2032 return 2033 } 2034 2035 // SetSMTPPassword safely sets the Configuration value for state's 'SMTPPassword' field 2036 func (st *ConfigState) SetSMTPPassword(v string) { 2037 st.mutex.Lock() 2038 defer st.mutex.Unlock() 2039 st.config.SMTPPassword = v 2040 st.reloadToViper() 2041 } 2042 2043 // SMTPPasswordFlag returns the flag name for the 'SMTPPassword' field 2044 func SMTPPasswordFlag() string { return "smtp-password" } 2045 2046 // GetSMTPPassword safely fetches the value for global configuration 'SMTPPassword' field 2047 func GetSMTPPassword() string { return global.GetSMTPPassword() } 2048 2049 // SetSMTPPassword safely sets the value for global configuration 'SMTPPassword' field 2050 func SetSMTPPassword(v string) { global.SetSMTPPassword(v) } 2051 2052 // GetSMTPFrom safely fetches the Configuration value for state's 'SMTPFrom' field 2053 func (st *ConfigState) GetSMTPFrom() (v string) { 2054 st.mutex.Lock() 2055 v = st.config.SMTPFrom 2056 st.mutex.Unlock() 2057 return 2058 } 2059 2060 // SetSMTPFrom safely sets the Configuration value for state's 'SMTPFrom' field 2061 func (st *ConfigState) SetSMTPFrom(v string) { 2062 st.mutex.Lock() 2063 defer st.mutex.Unlock() 2064 st.config.SMTPFrom = v 2065 st.reloadToViper() 2066 } 2067 2068 // SMTPFromFlag returns the flag name for the 'SMTPFrom' field 2069 func SMTPFromFlag() string { return "smtp-from" } 2070 2071 // GetSMTPFrom safely fetches the value for global configuration 'SMTPFrom' field 2072 func GetSMTPFrom() string { return global.GetSMTPFrom() } 2073 2074 // SetSMTPFrom safely sets the value for global configuration 'SMTPFrom' field 2075 func SetSMTPFrom(v string) { global.SetSMTPFrom(v) } 2076 2077 // GetSMTPDiscloseRecipients safely fetches the Configuration value for state's 'SMTPDiscloseRecipients' field 2078 func (st *ConfigState) GetSMTPDiscloseRecipients() (v bool) { 2079 st.mutex.Lock() 2080 v = st.config.SMTPDiscloseRecipients 2081 st.mutex.Unlock() 2082 return 2083 } 2084 2085 // SetSMTPDiscloseRecipients safely sets the Configuration value for state's 'SMTPDiscloseRecipients' field 2086 func (st *ConfigState) SetSMTPDiscloseRecipients(v bool) { 2087 st.mutex.Lock() 2088 defer st.mutex.Unlock() 2089 st.config.SMTPDiscloseRecipients = v 2090 st.reloadToViper() 2091 } 2092 2093 // SMTPDiscloseRecipientsFlag returns the flag name for the 'SMTPDiscloseRecipients' field 2094 func SMTPDiscloseRecipientsFlag() string { return "smtp-disclose-recipients" } 2095 2096 // GetSMTPDiscloseRecipients safely fetches the value for global configuration 'SMTPDiscloseRecipients' field 2097 func GetSMTPDiscloseRecipients() bool { return global.GetSMTPDiscloseRecipients() } 2098 2099 // SetSMTPDiscloseRecipients safely sets the value for global configuration 'SMTPDiscloseRecipients' field 2100 func SetSMTPDiscloseRecipients(v bool) { global.SetSMTPDiscloseRecipients(v) } 2101 2102 // GetSyslogEnabled safely fetches the Configuration value for state's 'SyslogEnabled' field 2103 func (st *ConfigState) GetSyslogEnabled() (v bool) { 2104 st.mutex.Lock() 2105 v = st.config.SyslogEnabled 2106 st.mutex.Unlock() 2107 return 2108 } 2109 2110 // SetSyslogEnabled safely sets the Configuration value for state's 'SyslogEnabled' field 2111 func (st *ConfigState) SetSyslogEnabled(v bool) { 2112 st.mutex.Lock() 2113 defer st.mutex.Unlock() 2114 st.config.SyslogEnabled = v 2115 st.reloadToViper() 2116 } 2117 2118 // SyslogEnabledFlag returns the flag name for the 'SyslogEnabled' field 2119 func SyslogEnabledFlag() string { return "syslog-enabled" } 2120 2121 // GetSyslogEnabled safely fetches the value for global configuration 'SyslogEnabled' field 2122 func GetSyslogEnabled() bool { return global.GetSyslogEnabled() } 2123 2124 // SetSyslogEnabled safely sets the value for global configuration 'SyslogEnabled' field 2125 func SetSyslogEnabled(v bool) { global.SetSyslogEnabled(v) } 2126 2127 // GetSyslogProtocol safely fetches the Configuration value for state's 'SyslogProtocol' field 2128 func (st *ConfigState) GetSyslogProtocol() (v string) { 2129 st.mutex.Lock() 2130 v = st.config.SyslogProtocol 2131 st.mutex.Unlock() 2132 return 2133 } 2134 2135 // SetSyslogProtocol safely sets the Configuration value for state's 'SyslogProtocol' field 2136 func (st *ConfigState) SetSyslogProtocol(v string) { 2137 st.mutex.Lock() 2138 defer st.mutex.Unlock() 2139 st.config.SyslogProtocol = v 2140 st.reloadToViper() 2141 } 2142 2143 // SyslogProtocolFlag returns the flag name for the 'SyslogProtocol' field 2144 func SyslogProtocolFlag() string { return "syslog-protocol" } 2145 2146 // GetSyslogProtocol safely fetches the value for global configuration 'SyslogProtocol' field 2147 func GetSyslogProtocol() string { return global.GetSyslogProtocol() } 2148 2149 // SetSyslogProtocol safely sets the value for global configuration 'SyslogProtocol' field 2150 func SetSyslogProtocol(v string) { global.SetSyslogProtocol(v) } 2151 2152 // GetSyslogAddress safely fetches the Configuration value for state's 'SyslogAddress' field 2153 func (st *ConfigState) GetSyslogAddress() (v string) { 2154 st.mutex.Lock() 2155 v = st.config.SyslogAddress 2156 st.mutex.Unlock() 2157 return 2158 } 2159 2160 // SetSyslogAddress safely sets the Configuration value for state's 'SyslogAddress' field 2161 func (st *ConfigState) SetSyslogAddress(v string) { 2162 st.mutex.Lock() 2163 defer st.mutex.Unlock() 2164 st.config.SyslogAddress = v 2165 st.reloadToViper() 2166 } 2167 2168 // SyslogAddressFlag returns the flag name for the 'SyslogAddress' field 2169 func SyslogAddressFlag() string { return "syslog-address" } 2170 2171 // GetSyslogAddress safely fetches the value for global configuration 'SyslogAddress' field 2172 func GetSyslogAddress() string { return global.GetSyslogAddress() } 2173 2174 // SetSyslogAddress safely sets the value for global configuration 'SyslogAddress' field 2175 func SetSyslogAddress(v string) { global.SetSyslogAddress(v) } 2176 2177 // GetAdvancedCookiesSamesite safely fetches the Configuration value for state's 'AdvancedCookiesSamesite' field 2178 func (st *ConfigState) GetAdvancedCookiesSamesite() (v string) { 2179 st.mutex.Lock() 2180 v = st.config.AdvancedCookiesSamesite 2181 st.mutex.Unlock() 2182 return 2183 } 2184 2185 // SetAdvancedCookiesSamesite safely sets the Configuration value for state's 'AdvancedCookiesSamesite' field 2186 func (st *ConfigState) SetAdvancedCookiesSamesite(v string) { 2187 st.mutex.Lock() 2188 defer st.mutex.Unlock() 2189 st.config.AdvancedCookiesSamesite = v 2190 st.reloadToViper() 2191 } 2192 2193 // AdvancedCookiesSamesiteFlag returns the flag name for the 'AdvancedCookiesSamesite' field 2194 func AdvancedCookiesSamesiteFlag() string { return "advanced-cookies-samesite" } 2195 2196 // GetAdvancedCookiesSamesite safely fetches the value for global configuration 'AdvancedCookiesSamesite' field 2197 func GetAdvancedCookiesSamesite() string { return global.GetAdvancedCookiesSamesite() } 2198 2199 // SetAdvancedCookiesSamesite safely sets the value for global configuration 'AdvancedCookiesSamesite' field 2200 func SetAdvancedCookiesSamesite(v string) { global.SetAdvancedCookiesSamesite(v) } 2201 2202 // GetAdvancedRateLimitRequests safely fetches the Configuration value for state's 'AdvancedRateLimitRequests' field 2203 func (st *ConfigState) GetAdvancedRateLimitRequests() (v int) { 2204 st.mutex.Lock() 2205 v = st.config.AdvancedRateLimitRequests 2206 st.mutex.Unlock() 2207 return 2208 } 2209 2210 // SetAdvancedRateLimitRequests safely sets the Configuration value for state's 'AdvancedRateLimitRequests' field 2211 func (st *ConfigState) SetAdvancedRateLimitRequests(v int) { 2212 st.mutex.Lock() 2213 defer st.mutex.Unlock() 2214 st.config.AdvancedRateLimitRequests = v 2215 st.reloadToViper() 2216 } 2217 2218 // AdvancedRateLimitRequestsFlag returns the flag name for the 'AdvancedRateLimitRequests' field 2219 func AdvancedRateLimitRequestsFlag() string { return "advanced-rate-limit-requests" } 2220 2221 // GetAdvancedRateLimitRequests safely fetches the value for global configuration 'AdvancedRateLimitRequests' field 2222 func GetAdvancedRateLimitRequests() int { return global.GetAdvancedRateLimitRequests() } 2223 2224 // SetAdvancedRateLimitRequests safely sets the value for global configuration 'AdvancedRateLimitRequests' field 2225 func SetAdvancedRateLimitRequests(v int) { global.SetAdvancedRateLimitRequests(v) } 2226 2227 // GetAdvancedThrottlingMultiplier safely fetches the Configuration value for state's 'AdvancedThrottlingMultiplier' field 2228 func (st *ConfigState) GetAdvancedThrottlingMultiplier() (v int) { 2229 st.mutex.Lock() 2230 v = st.config.AdvancedThrottlingMultiplier 2231 st.mutex.Unlock() 2232 return 2233 } 2234 2235 // SetAdvancedThrottlingMultiplier safely sets the Configuration value for state's 'AdvancedThrottlingMultiplier' field 2236 func (st *ConfigState) SetAdvancedThrottlingMultiplier(v int) { 2237 st.mutex.Lock() 2238 defer st.mutex.Unlock() 2239 st.config.AdvancedThrottlingMultiplier = v 2240 st.reloadToViper() 2241 } 2242 2243 // AdvancedThrottlingMultiplierFlag returns the flag name for the 'AdvancedThrottlingMultiplier' field 2244 func AdvancedThrottlingMultiplierFlag() string { return "advanced-throttling-multiplier" } 2245 2246 // GetAdvancedThrottlingMultiplier safely fetches the value for global configuration 'AdvancedThrottlingMultiplier' field 2247 func GetAdvancedThrottlingMultiplier() int { return global.GetAdvancedThrottlingMultiplier() } 2248 2249 // SetAdvancedThrottlingMultiplier safely sets the value for global configuration 'AdvancedThrottlingMultiplier' field 2250 func SetAdvancedThrottlingMultiplier(v int) { global.SetAdvancedThrottlingMultiplier(v) } 2251 2252 // GetAdvancedThrottlingRetryAfter safely fetches the Configuration value for state's 'AdvancedThrottlingRetryAfter' field 2253 func (st *ConfigState) GetAdvancedThrottlingRetryAfter() (v time.Duration) { 2254 st.mutex.Lock() 2255 v = st.config.AdvancedThrottlingRetryAfter 2256 st.mutex.Unlock() 2257 return 2258 } 2259 2260 // SetAdvancedThrottlingRetryAfter safely sets the Configuration value for state's 'AdvancedThrottlingRetryAfter' field 2261 func (st *ConfigState) SetAdvancedThrottlingRetryAfter(v time.Duration) { 2262 st.mutex.Lock() 2263 defer st.mutex.Unlock() 2264 st.config.AdvancedThrottlingRetryAfter = v 2265 st.reloadToViper() 2266 } 2267 2268 // AdvancedThrottlingRetryAfterFlag returns the flag name for the 'AdvancedThrottlingRetryAfter' field 2269 func AdvancedThrottlingRetryAfterFlag() string { return "advanced-throttling-retry-after" } 2270 2271 // GetAdvancedThrottlingRetryAfter safely fetches the value for global configuration 'AdvancedThrottlingRetryAfter' field 2272 func GetAdvancedThrottlingRetryAfter() time.Duration { return global.GetAdvancedThrottlingRetryAfter() } 2273 2274 // SetAdvancedThrottlingRetryAfter safely sets the value for global configuration 'AdvancedThrottlingRetryAfter' field 2275 func SetAdvancedThrottlingRetryAfter(v time.Duration) { global.SetAdvancedThrottlingRetryAfter(v) } 2276 2277 // GetAdvancedSenderMultiplier safely fetches the Configuration value for state's 'AdvancedSenderMultiplier' field 2278 func (st *ConfigState) GetAdvancedSenderMultiplier() (v int) { 2279 st.mutex.Lock() 2280 v = st.config.AdvancedSenderMultiplier 2281 st.mutex.Unlock() 2282 return 2283 } 2284 2285 // SetAdvancedSenderMultiplier safely sets the Configuration value for state's 'AdvancedSenderMultiplier' field 2286 func (st *ConfigState) SetAdvancedSenderMultiplier(v int) { 2287 st.mutex.Lock() 2288 defer st.mutex.Unlock() 2289 st.config.AdvancedSenderMultiplier = v 2290 st.reloadToViper() 2291 } 2292 2293 // AdvancedSenderMultiplierFlag returns the flag name for the 'AdvancedSenderMultiplier' field 2294 func AdvancedSenderMultiplierFlag() string { return "advanced-sender-multiplier" } 2295 2296 // GetAdvancedSenderMultiplier safely fetches the value for global configuration 'AdvancedSenderMultiplier' field 2297 func GetAdvancedSenderMultiplier() int { return global.GetAdvancedSenderMultiplier() } 2298 2299 // SetAdvancedSenderMultiplier safely sets the value for global configuration 'AdvancedSenderMultiplier' field 2300 func SetAdvancedSenderMultiplier(v int) { global.SetAdvancedSenderMultiplier(v) } 2301 2302 // GetCacheGTSAccountMaxSize safely fetches the Configuration value for state's 'Cache.GTS.AccountMaxSize' field 2303 func (st *ConfigState) GetCacheGTSAccountMaxSize() (v int) { 2304 st.mutex.Lock() 2305 v = st.config.Cache.GTS.AccountMaxSize 2306 st.mutex.Unlock() 2307 return 2308 } 2309 2310 // SetCacheGTSAccountMaxSize safely sets the Configuration value for state's 'Cache.GTS.AccountMaxSize' field 2311 func (st *ConfigState) SetCacheGTSAccountMaxSize(v int) { 2312 st.mutex.Lock() 2313 defer st.mutex.Unlock() 2314 st.config.Cache.GTS.AccountMaxSize = v 2315 st.reloadToViper() 2316 } 2317 2318 // CacheGTSAccountMaxSizeFlag returns the flag name for the 'Cache.GTS.AccountMaxSize' field 2319 func CacheGTSAccountMaxSizeFlag() string { return "cache-gts-account-max-size" } 2320 2321 // GetCacheGTSAccountMaxSize safely fetches the value for global configuration 'Cache.GTS.AccountMaxSize' field 2322 func GetCacheGTSAccountMaxSize() int { return global.GetCacheGTSAccountMaxSize() } 2323 2324 // SetCacheGTSAccountMaxSize safely sets the value for global configuration 'Cache.GTS.AccountMaxSize' field 2325 func SetCacheGTSAccountMaxSize(v int) { global.SetCacheGTSAccountMaxSize(v) } 2326 2327 // GetCacheGTSAccountTTL safely fetches the Configuration value for state's 'Cache.GTS.AccountTTL' field 2328 func (st *ConfigState) GetCacheGTSAccountTTL() (v time.Duration) { 2329 st.mutex.Lock() 2330 v = st.config.Cache.GTS.AccountTTL 2331 st.mutex.Unlock() 2332 return 2333 } 2334 2335 // SetCacheGTSAccountTTL safely sets the Configuration value for state's 'Cache.GTS.AccountTTL' field 2336 func (st *ConfigState) SetCacheGTSAccountTTL(v time.Duration) { 2337 st.mutex.Lock() 2338 defer st.mutex.Unlock() 2339 st.config.Cache.GTS.AccountTTL = v 2340 st.reloadToViper() 2341 } 2342 2343 // CacheGTSAccountTTLFlag returns the flag name for the 'Cache.GTS.AccountTTL' field 2344 func CacheGTSAccountTTLFlag() string { return "cache-gts-account-ttl" } 2345 2346 // GetCacheGTSAccountTTL safely fetches the value for global configuration 'Cache.GTS.AccountTTL' field 2347 func GetCacheGTSAccountTTL() time.Duration { return global.GetCacheGTSAccountTTL() } 2348 2349 // SetCacheGTSAccountTTL safely sets the value for global configuration 'Cache.GTS.AccountTTL' field 2350 func SetCacheGTSAccountTTL(v time.Duration) { global.SetCacheGTSAccountTTL(v) } 2351 2352 // GetCacheGTSAccountSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.AccountSweepFreq' field 2353 func (st *ConfigState) GetCacheGTSAccountSweepFreq() (v time.Duration) { 2354 st.mutex.Lock() 2355 v = st.config.Cache.GTS.AccountSweepFreq 2356 st.mutex.Unlock() 2357 return 2358 } 2359 2360 // SetCacheGTSAccountSweepFreq safely sets the Configuration value for state's 'Cache.GTS.AccountSweepFreq' field 2361 func (st *ConfigState) SetCacheGTSAccountSweepFreq(v time.Duration) { 2362 st.mutex.Lock() 2363 defer st.mutex.Unlock() 2364 st.config.Cache.GTS.AccountSweepFreq = v 2365 st.reloadToViper() 2366 } 2367 2368 // CacheGTSAccountSweepFreqFlag returns the flag name for the 'Cache.GTS.AccountSweepFreq' field 2369 func CacheGTSAccountSweepFreqFlag() string { return "cache-gts-account-sweep-freq" } 2370 2371 // GetCacheGTSAccountSweepFreq safely fetches the value for global configuration 'Cache.GTS.AccountSweepFreq' field 2372 func GetCacheGTSAccountSweepFreq() time.Duration { return global.GetCacheGTSAccountSweepFreq() } 2373 2374 // SetCacheGTSAccountSweepFreq safely sets the value for global configuration 'Cache.GTS.AccountSweepFreq' field 2375 func SetCacheGTSAccountSweepFreq(v time.Duration) { global.SetCacheGTSAccountSweepFreq(v) } 2376 2377 // GetCacheGTSBlockMaxSize safely fetches the Configuration value for state's 'Cache.GTS.BlockMaxSize' field 2378 func (st *ConfigState) GetCacheGTSBlockMaxSize() (v int) { 2379 st.mutex.Lock() 2380 v = st.config.Cache.GTS.BlockMaxSize 2381 st.mutex.Unlock() 2382 return 2383 } 2384 2385 // SetCacheGTSBlockMaxSize safely sets the Configuration value for state's 'Cache.GTS.BlockMaxSize' field 2386 func (st *ConfigState) SetCacheGTSBlockMaxSize(v int) { 2387 st.mutex.Lock() 2388 defer st.mutex.Unlock() 2389 st.config.Cache.GTS.BlockMaxSize = v 2390 st.reloadToViper() 2391 } 2392 2393 // CacheGTSBlockMaxSizeFlag returns the flag name for the 'Cache.GTS.BlockMaxSize' field 2394 func CacheGTSBlockMaxSizeFlag() string { return "cache-gts-block-max-size" } 2395 2396 // GetCacheGTSBlockMaxSize safely fetches the value for global configuration 'Cache.GTS.BlockMaxSize' field 2397 func GetCacheGTSBlockMaxSize() int { return global.GetCacheGTSBlockMaxSize() } 2398 2399 // SetCacheGTSBlockMaxSize safely sets the value for global configuration 'Cache.GTS.BlockMaxSize' field 2400 func SetCacheGTSBlockMaxSize(v int) { global.SetCacheGTSBlockMaxSize(v) } 2401 2402 // GetCacheGTSBlockTTL safely fetches the Configuration value for state's 'Cache.GTS.BlockTTL' field 2403 func (st *ConfigState) GetCacheGTSBlockTTL() (v time.Duration) { 2404 st.mutex.Lock() 2405 v = st.config.Cache.GTS.BlockTTL 2406 st.mutex.Unlock() 2407 return 2408 } 2409 2410 // SetCacheGTSBlockTTL safely sets the Configuration value for state's 'Cache.GTS.BlockTTL' field 2411 func (st *ConfigState) SetCacheGTSBlockTTL(v time.Duration) { 2412 st.mutex.Lock() 2413 defer st.mutex.Unlock() 2414 st.config.Cache.GTS.BlockTTL = v 2415 st.reloadToViper() 2416 } 2417 2418 // CacheGTSBlockTTLFlag returns the flag name for the 'Cache.GTS.BlockTTL' field 2419 func CacheGTSBlockTTLFlag() string { return "cache-gts-block-ttl" } 2420 2421 // GetCacheGTSBlockTTL safely fetches the value for global configuration 'Cache.GTS.BlockTTL' field 2422 func GetCacheGTSBlockTTL() time.Duration { return global.GetCacheGTSBlockTTL() } 2423 2424 // SetCacheGTSBlockTTL safely sets the value for global configuration 'Cache.GTS.BlockTTL' field 2425 func SetCacheGTSBlockTTL(v time.Duration) { global.SetCacheGTSBlockTTL(v) } 2426 2427 // GetCacheGTSBlockSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.BlockSweepFreq' field 2428 func (st *ConfigState) GetCacheGTSBlockSweepFreq() (v time.Duration) { 2429 st.mutex.Lock() 2430 v = st.config.Cache.GTS.BlockSweepFreq 2431 st.mutex.Unlock() 2432 return 2433 } 2434 2435 // SetCacheGTSBlockSweepFreq safely sets the Configuration value for state's 'Cache.GTS.BlockSweepFreq' field 2436 func (st *ConfigState) SetCacheGTSBlockSweepFreq(v time.Duration) { 2437 st.mutex.Lock() 2438 defer st.mutex.Unlock() 2439 st.config.Cache.GTS.BlockSweepFreq = v 2440 st.reloadToViper() 2441 } 2442 2443 // CacheGTSBlockSweepFreqFlag returns the flag name for the 'Cache.GTS.BlockSweepFreq' field 2444 func CacheGTSBlockSweepFreqFlag() string { return "cache-gts-block-sweep-freq" } 2445 2446 // GetCacheGTSBlockSweepFreq safely fetches the value for global configuration 'Cache.GTS.BlockSweepFreq' field 2447 func GetCacheGTSBlockSweepFreq() time.Duration { return global.GetCacheGTSBlockSweepFreq() } 2448 2449 // SetCacheGTSBlockSweepFreq safely sets the value for global configuration 'Cache.GTS.BlockSweepFreq' field 2450 func SetCacheGTSBlockSweepFreq(v time.Duration) { global.SetCacheGTSBlockSweepFreq(v) } 2451 2452 // GetCacheGTSDomainBlockMaxSize safely fetches the Configuration value for state's 'Cache.GTS.DomainBlockMaxSize' field 2453 func (st *ConfigState) GetCacheGTSDomainBlockMaxSize() (v int) { 2454 st.mutex.Lock() 2455 v = st.config.Cache.GTS.DomainBlockMaxSize 2456 st.mutex.Unlock() 2457 return 2458 } 2459 2460 // SetCacheGTSDomainBlockMaxSize safely sets the Configuration value for state's 'Cache.GTS.DomainBlockMaxSize' field 2461 func (st *ConfigState) SetCacheGTSDomainBlockMaxSize(v int) { 2462 st.mutex.Lock() 2463 defer st.mutex.Unlock() 2464 st.config.Cache.GTS.DomainBlockMaxSize = v 2465 st.reloadToViper() 2466 } 2467 2468 // CacheGTSDomainBlockMaxSizeFlag returns the flag name for the 'Cache.GTS.DomainBlockMaxSize' field 2469 func CacheGTSDomainBlockMaxSizeFlag() string { return "cache-gts-domain-block-max-size" } 2470 2471 // GetCacheGTSDomainBlockMaxSize safely fetches the value for global configuration 'Cache.GTS.DomainBlockMaxSize' field 2472 func GetCacheGTSDomainBlockMaxSize() int { return global.GetCacheGTSDomainBlockMaxSize() } 2473 2474 // SetCacheGTSDomainBlockMaxSize safely sets the value for global configuration 'Cache.GTS.DomainBlockMaxSize' field 2475 func SetCacheGTSDomainBlockMaxSize(v int) { global.SetCacheGTSDomainBlockMaxSize(v) } 2476 2477 // GetCacheGTSDomainBlockTTL safely fetches the Configuration value for state's 'Cache.GTS.DomainBlockTTL' field 2478 func (st *ConfigState) GetCacheGTSDomainBlockTTL() (v time.Duration) { 2479 st.mutex.Lock() 2480 v = st.config.Cache.GTS.DomainBlockTTL 2481 st.mutex.Unlock() 2482 return 2483 } 2484 2485 // SetCacheGTSDomainBlockTTL safely sets the Configuration value for state's 'Cache.GTS.DomainBlockTTL' field 2486 func (st *ConfigState) SetCacheGTSDomainBlockTTL(v time.Duration) { 2487 st.mutex.Lock() 2488 defer st.mutex.Unlock() 2489 st.config.Cache.GTS.DomainBlockTTL = v 2490 st.reloadToViper() 2491 } 2492 2493 // CacheGTSDomainBlockTTLFlag returns the flag name for the 'Cache.GTS.DomainBlockTTL' field 2494 func CacheGTSDomainBlockTTLFlag() string { return "cache-gts-domain-block-ttl" } 2495 2496 // GetCacheGTSDomainBlockTTL safely fetches the value for global configuration 'Cache.GTS.DomainBlockTTL' field 2497 func GetCacheGTSDomainBlockTTL() time.Duration { return global.GetCacheGTSDomainBlockTTL() } 2498 2499 // SetCacheGTSDomainBlockTTL safely sets the value for global configuration 'Cache.GTS.DomainBlockTTL' field 2500 func SetCacheGTSDomainBlockTTL(v time.Duration) { global.SetCacheGTSDomainBlockTTL(v) } 2501 2502 // GetCacheGTSDomainBlockSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.DomainBlockSweepFreq' field 2503 func (st *ConfigState) GetCacheGTSDomainBlockSweepFreq() (v time.Duration) { 2504 st.mutex.Lock() 2505 v = st.config.Cache.GTS.DomainBlockSweepFreq 2506 st.mutex.Unlock() 2507 return 2508 } 2509 2510 // SetCacheGTSDomainBlockSweepFreq safely sets the Configuration value for state's 'Cache.GTS.DomainBlockSweepFreq' field 2511 func (st *ConfigState) SetCacheGTSDomainBlockSweepFreq(v time.Duration) { 2512 st.mutex.Lock() 2513 defer st.mutex.Unlock() 2514 st.config.Cache.GTS.DomainBlockSweepFreq = v 2515 st.reloadToViper() 2516 } 2517 2518 // CacheGTSDomainBlockSweepFreqFlag returns the flag name for the 'Cache.GTS.DomainBlockSweepFreq' field 2519 func CacheGTSDomainBlockSweepFreqFlag() string { return "cache-gts-domain-block-sweep-freq" } 2520 2521 // GetCacheGTSDomainBlockSweepFreq safely fetches the value for global configuration 'Cache.GTS.DomainBlockSweepFreq' field 2522 func GetCacheGTSDomainBlockSweepFreq() time.Duration { return global.GetCacheGTSDomainBlockSweepFreq() } 2523 2524 // SetCacheGTSDomainBlockSweepFreq safely sets the value for global configuration 'Cache.GTS.DomainBlockSweepFreq' field 2525 func SetCacheGTSDomainBlockSweepFreq(v time.Duration) { global.SetCacheGTSDomainBlockSweepFreq(v) } 2526 2527 // GetCacheGTSEmojiMaxSize safely fetches the Configuration value for state's 'Cache.GTS.EmojiMaxSize' field 2528 func (st *ConfigState) GetCacheGTSEmojiMaxSize() (v int) { 2529 st.mutex.Lock() 2530 v = st.config.Cache.GTS.EmojiMaxSize 2531 st.mutex.Unlock() 2532 return 2533 } 2534 2535 // SetCacheGTSEmojiMaxSize safely sets the Configuration value for state's 'Cache.GTS.EmojiMaxSize' field 2536 func (st *ConfigState) SetCacheGTSEmojiMaxSize(v int) { 2537 st.mutex.Lock() 2538 defer st.mutex.Unlock() 2539 st.config.Cache.GTS.EmojiMaxSize = v 2540 st.reloadToViper() 2541 } 2542 2543 // CacheGTSEmojiMaxSizeFlag returns the flag name for the 'Cache.GTS.EmojiMaxSize' field 2544 func CacheGTSEmojiMaxSizeFlag() string { return "cache-gts-emoji-max-size" } 2545 2546 // GetCacheGTSEmojiMaxSize safely fetches the value for global configuration 'Cache.GTS.EmojiMaxSize' field 2547 func GetCacheGTSEmojiMaxSize() int { return global.GetCacheGTSEmojiMaxSize() } 2548 2549 // SetCacheGTSEmojiMaxSize safely sets the value for global configuration 'Cache.GTS.EmojiMaxSize' field 2550 func SetCacheGTSEmojiMaxSize(v int) { global.SetCacheGTSEmojiMaxSize(v) } 2551 2552 // GetCacheGTSEmojiTTL safely fetches the Configuration value for state's 'Cache.GTS.EmojiTTL' field 2553 func (st *ConfigState) GetCacheGTSEmojiTTL() (v time.Duration) { 2554 st.mutex.Lock() 2555 v = st.config.Cache.GTS.EmojiTTL 2556 st.mutex.Unlock() 2557 return 2558 } 2559 2560 // SetCacheGTSEmojiTTL safely sets the Configuration value for state's 'Cache.GTS.EmojiTTL' field 2561 func (st *ConfigState) SetCacheGTSEmojiTTL(v time.Duration) { 2562 st.mutex.Lock() 2563 defer st.mutex.Unlock() 2564 st.config.Cache.GTS.EmojiTTL = v 2565 st.reloadToViper() 2566 } 2567 2568 // CacheGTSEmojiTTLFlag returns the flag name for the 'Cache.GTS.EmojiTTL' field 2569 func CacheGTSEmojiTTLFlag() string { return "cache-gts-emoji-ttl" } 2570 2571 // GetCacheGTSEmojiTTL safely fetches the value for global configuration 'Cache.GTS.EmojiTTL' field 2572 func GetCacheGTSEmojiTTL() time.Duration { return global.GetCacheGTSEmojiTTL() } 2573 2574 // SetCacheGTSEmojiTTL safely sets the value for global configuration 'Cache.GTS.EmojiTTL' field 2575 func SetCacheGTSEmojiTTL(v time.Duration) { global.SetCacheGTSEmojiTTL(v) } 2576 2577 // GetCacheGTSEmojiSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.EmojiSweepFreq' field 2578 func (st *ConfigState) GetCacheGTSEmojiSweepFreq() (v time.Duration) { 2579 st.mutex.Lock() 2580 v = st.config.Cache.GTS.EmojiSweepFreq 2581 st.mutex.Unlock() 2582 return 2583 } 2584 2585 // SetCacheGTSEmojiSweepFreq safely sets the Configuration value for state's 'Cache.GTS.EmojiSweepFreq' field 2586 func (st *ConfigState) SetCacheGTSEmojiSweepFreq(v time.Duration) { 2587 st.mutex.Lock() 2588 defer st.mutex.Unlock() 2589 st.config.Cache.GTS.EmojiSweepFreq = v 2590 st.reloadToViper() 2591 } 2592 2593 // CacheGTSEmojiSweepFreqFlag returns the flag name for the 'Cache.GTS.EmojiSweepFreq' field 2594 func CacheGTSEmojiSweepFreqFlag() string { return "cache-gts-emoji-sweep-freq" } 2595 2596 // GetCacheGTSEmojiSweepFreq safely fetches the value for global configuration 'Cache.GTS.EmojiSweepFreq' field 2597 func GetCacheGTSEmojiSweepFreq() time.Duration { return global.GetCacheGTSEmojiSweepFreq() } 2598 2599 // SetCacheGTSEmojiSweepFreq safely sets the value for global configuration 'Cache.GTS.EmojiSweepFreq' field 2600 func SetCacheGTSEmojiSweepFreq(v time.Duration) { global.SetCacheGTSEmojiSweepFreq(v) } 2601 2602 // GetCacheGTSEmojiCategoryMaxSize safely fetches the Configuration value for state's 'Cache.GTS.EmojiCategoryMaxSize' field 2603 func (st *ConfigState) GetCacheGTSEmojiCategoryMaxSize() (v int) { 2604 st.mutex.Lock() 2605 v = st.config.Cache.GTS.EmojiCategoryMaxSize 2606 st.mutex.Unlock() 2607 return 2608 } 2609 2610 // SetCacheGTSEmojiCategoryMaxSize safely sets the Configuration value for state's 'Cache.GTS.EmojiCategoryMaxSize' field 2611 func (st *ConfigState) SetCacheGTSEmojiCategoryMaxSize(v int) { 2612 st.mutex.Lock() 2613 defer st.mutex.Unlock() 2614 st.config.Cache.GTS.EmojiCategoryMaxSize = v 2615 st.reloadToViper() 2616 } 2617 2618 // CacheGTSEmojiCategoryMaxSizeFlag returns the flag name for the 'Cache.GTS.EmojiCategoryMaxSize' field 2619 func CacheGTSEmojiCategoryMaxSizeFlag() string { return "cache-gts-emoji-category-max-size" } 2620 2621 // GetCacheGTSEmojiCategoryMaxSize safely fetches the value for global configuration 'Cache.GTS.EmojiCategoryMaxSize' field 2622 func GetCacheGTSEmojiCategoryMaxSize() int { return global.GetCacheGTSEmojiCategoryMaxSize() } 2623 2624 // SetCacheGTSEmojiCategoryMaxSize safely sets the value for global configuration 'Cache.GTS.EmojiCategoryMaxSize' field 2625 func SetCacheGTSEmojiCategoryMaxSize(v int) { global.SetCacheGTSEmojiCategoryMaxSize(v) } 2626 2627 // GetCacheGTSEmojiCategoryTTL safely fetches the Configuration value for state's 'Cache.GTS.EmojiCategoryTTL' field 2628 func (st *ConfigState) GetCacheGTSEmojiCategoryTTL() (v time.Duration) { 2629 st.mutex.Lock() 2630 v = st.config.Cache.GTS.EmojiCategoryTTL 2631 st.mutex.Unlock() 2632 return 2633 } 2634 2635 // SetCacheGTSEmojiCategoryTTL safely sets the Configuration value for state's 'Cache.GTS.EmojiCategoryTTL' field 2636 func (st *ConfigState) SetCacheGTSEmojiCategoryTTL(v time.Duration) { 2637 st.mutex.Lock() 2638 defer st.mutex.Unlock() 2639 st.config.Cache.GTS.EmojiCategoryTTL = v 2640 st.reloadToViper() 2641 } 2642 2643 // CacheGTSEmojiCategoryTTLFlag returns the flag name for the 'Cache.GTS.EmojiCategoryTTL' field 2644 func CacheGTSEmojiCategoryTTLFlag() string { return "cache-gts-emoji-category-ttl" } 2645 2646 // GetCacheGTSEmojiCategoryTTL safely fetches the value for global configuration 'Cache.GTS.EmojiCategoryTTL' field 2647 func GetCacheGTSEmojiCategoryTTL() time.Duration { return global.GetCacheGTSEmojiCategoryTTL() } 2648 2649 // SetCacheGTSEmojiCategoryTTL safely sets the value for global configuration 'Cache.GTS.EmojiCategoryTTL' field 2650 func SetCacheGTSEmojiCategoryTTL(v time.Duration) { global.SetCacheGTSEmojiCategoryTTL(v) } 2651 2652 // GetCacheGTSEmojiCategorySweepFreq safely fetches the Configuration value for state's 'Cache.GTS.EmojiCategorySweepFreq' field 2653 func (st *ConfigState) GetCacheGTSEmojiCategorySweepFreq() (v time.Duration) { 2654 st.mutex.Lock() 2655 v = st.config.Cache.GTS.EmojiCategorySweepFreq 2656 st.mutex.Unlock() 2657 return 2658 } 2659 2660 // SetCacheGTSEmojiCategorySweepFreq safely sets the Configuration value for state's 'Cache.GTS.EmojiCategorySweepFreq' field 2661 func (st *ConfigState) SetCacheGTSEmojiCategorySweepFreq(v time.Duration) { 2662 st.mutex.Lock() 2663 defer st.mutex.Unlock() 2664 st.config.Cache.GTS.EmojiCategorySweepFreq = v 2665 st.reloadToViper() 2666 } 2667 2668 // CacheGTSEmojiCategorySweepFreqFlag returns the flag name for the 'Cache.GTS.EmojiCategorySweepFreq' field 2669 func CacheGTSEmojiCategorySweepFreqFlag() string { return "cache-gts-emoji-category-sweep-freq" } 2670 2671 // GetCacheGTSEmojiCategorySweepFreq safely fetches the value for global configuration 'Cache.GTS.EmojiCategorySweepFreq' field 2672 func GetCacheGTSEmojiCategorySweepFreq() time.Duration { 2673 return global.GetCacheGTSEmojiCategorySweepFreq() 2674 } 2675 2676 // SetCacheGTSEmojiCategorySweepFreq safely sets the value for global configuration 'Cache.GTS.EmojiCategorySweepFreq' field 2677 func SetCacheGTSEmojiCategorySweepFreq(v time.Duration) { global.SetCacheGTSEmojiCategorySweepFreq(v) } 2678 2679 // GetCacheGTSFollowMaxSize safely fetches the Configuration value for state's 'Cache.GTS.FollowMaxSize' field 2680 func (st *ConfigState) GetCacheGTSFollowMaxSize() (v int) { 2681 st.mutex.Lock() 2682 v = st.config.Cache.GTS.FollowMaxSize 2683 st.mutex.Unlock() 2684 return 2685 } 2686 2687 // SetCacheGTSFollowMaxSize safely sets the Configuration value for state's 'Cache.GTS.FollowMaxSize' field 2688 func (st *ConfigState) SetCacheGTSFollowMaxSize(v int) { 2689 st.mutex.Lock() 2690 defer st.mutex.Unlock() 2691 st.config.Cache.GTS.FollowMaxSize = v 2692 st.reloadToViper() 2693 } 2694 2695 // CacheGTSFollowMaxSizeFlag returns the flag name for the 'Cache.GTS.FollowMaxSize' field 2696 func CacheGTSFollowMaxSizeFlag() string { return "cache-gts-follow-max-size" } 2697 2698 // GetCacheGTSFollowMaxSize safely fetches the value for global configuration 'Cache.GTS.FollowMaxSize' field 2699 func GetCacheGTSFollowMaxSize() int { return global.GetCacheGTSFollowMaxSize() } 2700 2701 // SetCacheGTSFollowMaxSize safely sets the value for global configuration 'Cache.GTS.FollowMaxSize' field 2702 func SetCacheGTSFollowMaxSize(v int) { global.SetCacheGTSFollowMaxSize(v) } 2703 2704 // GetCacheGTSFollowTTL safely fetches the Configuration value for state's 'Cache.GTS.FollowTTL' field 2705 func (st *ConfigState) GetCacheGTSFollowTTL() (v time.Duration) { 2706 st.mutex.Lock() 2707 v = st.config.Cache.GTS.FollowTTL 2708 st.mutex.Unlock() 2709 return 2710 } 2711 2712 // SetCacheGTSFollowTTL safely sets the Configuration value for state's 'Cache.GTS.FollowTTL' field 2713 func (st *ConfigState) SetCacheGTSFollowTTL(v time.Duration) { 2714 st.mutex.Lock() 2715 defer st.mutex.Unlock() 2716 st.config.Cache.GTS.FollowTTL = v 2717 st.reloadToViper() 2718 } 2719 2720 // CacheGTSFollowTTLFlag returns the flag name for the 'Cache.GTS.FollowTTL' field 2721 func CacheGTSFollowTTLFlag() string { return "cache-gts-follow-ttl" } 2722 2723 // GetCacheGTSFollowTTL safely fetches the value for global configuration 'Cache.GTS.FollowTTL' field 2724 func GetCacheGTSFollowTTL() time.Duration { return global.GetCacheGTSFollowTTL() } 2725 2726 // SetCacheGTSFollowTTL safely sets the value for global configuration 'Cache.GTS.FollowTTL' field 2727 func SetCacheGTSFollowTTL(v time.Duration) { global.SetCacheGTSFollowTTL(v) } 2728 2729 // GetCacheGTSFollowSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.FollowSweepFreq' field 2730 func (st *ConfigState) GetCacheGTSFollowSweepFreq() (v time.Duration) { 2731 st.mutex.Lock() 2732 v = st.config.Cache.GTS.FollowSweepFreq 2733 st.mutex.Unlock() 2734 return 2735 } 2736 2737 // SetCacheGTSFollowSweepFreq safely sets the Configuration value for state's 'Cache.GTS.FollowSweepFreq' field 2738 func (st *ConfigState) SetCacheGTSFollowSweepFreq(v time.Duration) { 2739 st.mutex.Lock() 2740 defer st.mutex.Unlock() 2741 st.config.Cache.GTS.FollowSweepFreq = v 2742 st.reloadToViper() 2743 } 2744 2745 // CacheGTSFollowSweepFreqFlag returns the flag name for the 'Cache.GTS.FollowSweepFreq' field 2746 func CacheGTSFollowSweepFreqFlag() string { return "cache-gts-follow-sweep-freq" } 2747 2748 // GetCacheGTSFollowSweepFreq safely fetches the value for global configuration 'Cache.GTS.FollowSweepFreq' field 2749 func GetCacheGTSFollowSweepFreq() time.Duration { return global.GetCacheGTSFollowSweepFreq() } 2750 2751 // SetCacheGTSFollowSweepFreq safely sets the value for global configuration 'Cache.GTS.FollowSweepFreq' field 2752 func SetCacheGTSFollowSweepFreq(v time.Duration) { global.SetCacheGTSFollowSweepFreq(v) } 2753 2754 // GetCacheGTSFollowRequestMaxSize safely fetches the Configuration value for state's 'Cache.GTS.FollowRequestMaxSize' field 2755 func (st *ConfigState) GetCacheGTSFollowRequestMaxSize() (v int) { 2756 st.mutex.Lock() 2757 v = st.config.Cache.GTS.FollowRequestMaxSize 2758 st.mutex.Unlock() 2759 return 2760 } 2761 2762 // SetCacheGTSFollowRequestMaxSize safely sets the Configuration value for state's 'Cache.GTS.FollowRequestMaxSize' field 2763 func (st *ConfigState) SetCacheGTSFollowRequestMaxSize(v int) { 2764 st.mutex.Lock() 2765 defer st.mutex.Unlock() 2766 st.config.Cache.GTS.FollowRequestMaxSize = v 2767 st.reloadToViper() 2768 } 2769 2770 // CacheGTSFollowRequestMaxSizeFlag returns the flag name for the 'Cache.GTS.FollowRequestMaxSize' field 2771 func CacheGTSFollowRequestMaxSizeFlag() string { return "cache-gts-follow-request-max-size" } 2772 2773 // GetCacheGTSFollowRequestMaxSize safely fetches the value for global configuration 'Cache.GTS.FollowRequestMaxSize' field 2774 func GetCacheGTSFollowRequestMaxSize() int { return global.GetCacheGTSFollowRequestMaxSize() } 2775 2776 // SetCacheGTSFollowRequestMaxSize safely sets the value for global configuration 'Cache.GTS.FollowRequestMaxSize' field 2777 func SetCacheGTSFollowRequestMaxSize(v int) { global.SetCacheGTSFollowRequestMaxSize(v) } 2778 2779 // GetCacheGTSFollowRequestTTL safely fetches the Configuration value for state's 'Cache.GTS.FollowRequestTTL' field 2780 func (st *ConfigState) GetCacheGTSFollowRequestTTL() (v time.Duration) { 2781 st.mutex.Lock() 2782 v = st.config.Cache.GTS.FollowRequestTTL 2783 st.mutex.Unlock() 2784 return 2785 } 2786 2787 // SetCacheGTSFollowRequestTTL safely sets the Configuration value for state's 'Cache.GTS.FollowRequestTTL' field 2788 func (st *ConfigState) SetCacheGTSFollowRequestTTL(v time.Duration) { 2789 st.mutex.Lock() 2790 defer st.mutex.Unlock() 2791 st.config.Cache.GTS.FollowRequestTTL = v 2792 st.reloadToViper() 2793 } 2794 2795 // CacheGTSFollowRequestTTLFlag returns the flag name for the 'Cache.GTS.FollowRequestTTL' field 2796 func CacheGTSFollowRequestTTLFlag() string { return "cache-gts-follow-request-ttl" } 2797 2798 // GetCacheGTSFollowRequestTTL safely fetches the value for global configuration 'Cache.GTS.FollowRequestTTL' field 2799 func GetCacheGTSFollowRequestTTL() time.Duration { return global.GetCacheGTSFollowRequestTTL() } 2800 2801 // SetCacheGTSFollowRequestTTL safely sets the value for global configuration 'Cache.GTS.FollowRequestTTL' field 2802 func SetCacheGTSFollowRequestTTL(v time.Duration) { global.SetCacheGTSFollowRequestTTL(v) } 2803 2804 // GetCacheGTSFollowRequestSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.FollowRequestSweepFreq' field 2805 func (st *ConfigState) GetCacheGTSFollowRequestSweepFreq() (v time.Duration) { 2806 st.mutex.Lock() 2807 v = st.config.Cache.GTS.FollowRequestSweepFreq 2808 st.mutex.Unlock() 2809 return 2810 } 2811 2812 // SetCacheGTSFollowRequestSweepFreq safely sets the Configuration value for state's 'Cache.GTS.FollowRequestSweepFreq' field 2813 func (st *ConfigState) SetCacheGTSFollowRequestSweepFreq(v time.Duration) { 2814 st.mutex.Lock() 2815 defer st.mutex.Unlock() 2816 st.config.Cache.GTS.FollowRequestSweepFreq = v 2817 st.reloadToViper() 2818 } 2819 2820 // CacheGTSFollowRequestSweepFreqFlag returns the flag name for the 'Cache.GTS.FollowRequestSweepFreq' field 2821 func CacheGTSFollowRequestSweepFreqFlag() string { return "cache-gts-follow-request-sweep-freq" } 2822 2823 // GetCacheGTSFollowRequestSweepFreq safely fetches the value for global configuration 'Cache.GTS.FollowRequestSweepFreq' field 2824 func GetCacheGTSFollowRequestSweepFreq() time.Duration { 2825 return global.GetCacheGTSFollowRequestSweepFreq() 2826 } 2827 2828 // SetCacheGTSFollowRequestSweepFreq safely sets the value for global configuration 'Cache.GTS.FollowRequestSweepFreq' field 2829 func SetCacheGTSFollowRequestSweepFreq(v time.Duration) { global.SetCacheGTSFollowRequestSweepFreq(v) } 2830 2831 // GetCacheGTSListMaxSize safely fetches the Configuration value for state's 'Cache.GTS.ListMaxSize' field 2832 func (st *ConfigState) GetCacheGTSListMaxSize() (v int) { 2833 st.mutex.Lock() 2834 v = st.config.Cache.GTS.ListMaxSize 2835 st.mutex.Unlock() 2836 return 2837 } 2838 2839 // SetCacheGTSListMaxSize safely sets the Configuration value for state's 'Cache.GTS.ListMaxSize' field 2840 func (st *ConfigState) SetCacheGTSListMaxSize(v int) { 2841 st.mutex.Lock() 2842 defer st.mutex.Unlock() 2843 st.config.Cache.GTS.ListMaxSize = v 2844 st.reloadToViper() 2845 } 2846 2847 // CacheGTSListMaxSizeFlag returns the flag name for the 'Cache.GTS.ListMaxSize' field 2848 func CacheGTSListMaxSizeFlag() string { return "cache-gts-list-max-size" } 2849 2850 // GetCacheGTSListMaxSize safely fetches the value for global configuration 'Cache.GTS.ListMaxSize' field 2851 func GetCacheGTSListMaxSize() int { return global.GetCacheGTSListMaxSize() } 2852 2853 // SetCacheGTSListMaxSize safely sets the value for global configuration 'Cache.GTS.ListMaxSize' field 2854 func SetCacheGTSListMaxSize(v int) { global.SetCacheGTSListMaxSize(v) } 2855 2856 // GetCacheGTSListTTL safely fetches the Configuration value for state's 'Cache.GTS.ListTTL' field 2857 func (st *ConfigState) GetCacheGTSListTTL() (v time.Duration) { 2858 st.mutex.Lock() 2859 v = st.config.Cache.GTS.ListTTL 2860 st.mutex.Unlock() 2861 return 2862 } 2863 2864 // SetCacheGTSListTTL safely sets the Configuration value for state's 'Cache.GTS.ListTTL' field 2865 func (st *ConfigState) SetCacheGTSListTTL(v time.Duration) { 2866 st.mutex.Lock() 2867 defer st.mutex.Unlock() 2868 st.config.Cache.GTS.ListTTL = v 2869 st.reloadToViper() 2870 } 2871 2872 // CacheGTSListTTLFlag returns the flag name for the 'Cache.GTS.ListTTL' field 2873 func CacheGTSListTTLFlag() string { return "cache-gts-list-ttl" } 2874 2875 // GetCacheGTSListTTL safely fetches the value for global configuration 'Cache.GTS.ListTTL' field 2876 func GetCacheGTSListTTL() time.Duration { return global.GetCacheGTSListTTL() } 2877 2878 // SetCacheGTSListTTL safely sets the value for global configuration 'Cache.GTS.ListTTL' field 2879 func SetCacheGTSListTTL(v time.Duration) { global.SetCacheGTSListTTL(v) } 2880 2881 // GetCacheGTSListSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.ListSweepFreq' field 2882 func (st *ConfigState) GetCacheGTSListSweepFreq() (v time.Duration) { 2883 st.mutex.Lock() 2884 v = st.config.Cache.GTS.ListSweepFreq 2885 st.mutex.Unlock() 2886 return 2887 } 2888 2889 // SetCacheGTSListSweepFreq safely sets the Configuration value for state's 'Cache.GTS.ListSweepFreq' field 2890 func (st *ConfigState) SetCacheGTSListSweepFreq(v time.Duration) { 2891 st.mutex.Lock() 2892 defer st.mutex.Unlock() 2893 st.config.Cache.GTS.ListSweepFreq = v 2894 st.reloadToViper() 2895 } 2896 2897 // CacheGTSListSweepFreqFlag returns the flag name for the 'Cache.GTS.ListSweepFreq' field 2898 func CacheGTSListSweepFreqFlag() string { return "cache-gts-list-sweep-freq" } 2899 2900 // GetCacheGTSListSweepFreq safely fetches the value for global configuration 'Cache.GTS.ListSweepFreq' field 2901 func GetCacheGTSListSweepFreq() time.Duration { return global.GetCacheGTSListSweepFreq() } 2902 2903 // SetCacheGTSListSweepFreq safely sets the value for global configuration 'Cache.GTS.ListSweepFreq' field 2904 func SetCacheGTSListSweepFreq(v time.Duration) { global.SetCacheGTSListSweepFreq(v) } 2905 2906 // GetCacheGTSListEntryMaxSize safely fetches the Configuration value for state's 'Cache.GTS.ListEntryMaxSize' field 2907 func (st *ConfigState) GetCacheGTSListEntryMaxSize() (v int) { 2908 st.mutex.Lock() 2909 v = st.config.Cache.GTS.ListEntryMaxSize 2910 st.mutex.Unlock() 2911 return 2912 } 2913 2914 // SetCacheGTSListEntryMaxSize safely sets the Configuration value for state's 'Cache.GTS.ListEntryMaxSize' field 2915 func (st *ConfigState) SetCacheGTSListEntryMaxSize(v int) { 2916 st.mutex.Lock() 2917 defer st.mutex.Unlock() 2918 st.config.Cache.GTS.ListEntryMaxSize = v 2919 st.reloadToViper() 2920 } 2921 2922 // CacheGTSListEntryMaxSizeFlag returns the flag name for the 'Cache.GTS.ListEntryMaxSize' field 2923 func CacheGTSListEntryMaxSizeFlag() string { return "cache-gts-list-entry-max-size" } 2924 2925 // GetCacheGTSListEntryMaxSize safely fetches the value for global configuration 'Cache.GTS.ListEntryMaxSize' field 2926 func GetCacheGTSListEntryMaxSize() int { return global.GetCacheGTSListEntryMaxSize() } 2927 2928 // SetCacheGTSListEntryMaxSize safely sets the value for global configuration 'Cache.GTS.ListEntryMaxSize' field 2929 func SetCacheGTSListEntryMaxSize(v int) { global.SetCacheGTSListEntryMaxSize(v) } 2930 2931 // GetCacheGTSListEntryTTL safely fetches the Configuration value for state's 'Cache.GTS.ListEntryTTL' field 2932 func (st *ConfigState) GetCacheGTSListEntryTTL() (v time.Duration) { 2933 st.mutex.Lock() 2934 v = st.config.Cache.GTS.ListEntryTTL 2935 st.mutex.Unlock() 2936 return 2937 } 2938 2939 // SetCacheGTSListEntryTTL safely sets the Configuration value for state's 'Cache.GTS.ListEntryTTL' field 2940 func (st *ConfigState) SetCacheGTSListEntryTTL(v time.Duration) { 2941 st.mutex.Lock() 2942 defer st.mutex.Unlock() 2943 st.config.Cache.GTS.ListEntryTTL = v 2944 st.reloadToViper() 2945 } 2946 2947 // CacheGTSListEntryTTLFlag returns the flag name for the 'Cache.GTS.ListEntryTTL' field 2948 func CacheGTSListEntryTTLFlag() string { return "cache-gts-list-entry-ttl" } 2949 2950 // GetCacheGTSListEntryTTL safely fetches the value for global configuration 'Cache.GTS.ListEntryTTL' field 2951 func GetCacheGTSListEntryTTL() time.Duration { return global.GetCacheGTSListEntryTTL() } 2952 2953 // SetCacheGTSListEntryTTL safely sets the value for global configuration 'Cache.GTS.ListEntryTTL' field 2954 func SetCacheGTSListEntryTTL(v time.Duration) { global.SetCacheGTSListEntryTTL(v) } 2955 2956 // GetCacheGTSListEntrySweepFreq safely fetches the Configuration value for state's 'Cache.GTS.ListEntrySweepFreq' field 2957 func (st *ConfigState) GetCacheGTSListEntrySweepFreq() (v time.Duration) { 2958 st.mutex.Lock() 2959 v = st.config.Cache.GTS.ListEntrySweepFreq 2960 st.mutex.Unlock() 2961 return 2962 } 2963 2964 // SetCacheGTSListEntrySweepFreq safely sets the Configuration value for state's 'Cache.GTS.ListEntrySweepFreq' field 2965 func (st *ConfigState) SetCacheGTSListEntrySweepFreq(v time.Duration) { 2966 st.mutex.Lock() 2967 defer st.mutex.Unlock() 2968 st.config.Cache.GTS.ListEntrySweepFreq = v 2969 st.reloadToViper() 2970 } 2971 2972 // CacheGTSListEntrySweepFreqFlag returns the flag name for the 'Cache.GTS.ListEntrySweepFreq' field 2973 func CacheGTSListEntrySweepFreqFlag() string { return "cache-gts-list-entry-sweep-freq" } 2974 2975 // GetCacheGTSListEntrySweepFreq safely fetches the value for global configuration 'Cache.GTS.ListEntrySweepFreq' field 2976 func GetCacheGTSListEntrySweepFreq() time.Duration { return global.GetCacheGTSListEntrySweepFreq() } 2977 2978 // SetCacheGTSListEntrySweepFreq safely sets the value for global configuration 'Cache.GTS.ListEntrySweepFreq' field 2979 func SetCacheGTSListEntrySweepFreq(v time.Duration) { global.SetCacheGTSListEntrySweepFreq(v) } 2980 2981 // GetCacheGTSMediaMaxSize safely fetches the Configuration value for state's 'Cache.GTS.MediaMaxSize' field 2982 func (st *ConfigState) GetCacheGTSMediaMaxSize() (v int) { 2983 st.mutex.Lock() 2984 v = st.config.Cache.GTS.MediaMaxSize 2985 st.mutex.Unlock() 2986 return 2987 } 2988 2989 // SetCacheGTSMediaMaxSize safely sets the Configuration value for state's 'Cache.GTS.MediaMaxSize' field 2990 func (st *ConfigState) SetCacheGTSMediaMaxSize(v int) { 2991 st.mutex.Lock() 2992 defer st.mutex.Unlock() 2993 st.config.Cache.GTS.MediaMaxSize = v 2994 st.reloadToViper() 2995 } 2996 2997 // CacheGTSMediaMaxSizeFlag returns the flag name for the 'Cache.GTS.MediaMaxSize' field 2998 func CacheGTSMediaMaxSizeFlag() string { return "cache-gts-media-max-size" } 2999 3000 // GetCacheGTSMediaMaxSize safely fetches the value for global configuration 'Cache.GTS.MediaMaxSize' field 3001 func GetCacheGTSMediaMaxSize() int { return global.GetCacheGTSMediaMaxSize() } 3002 3003 // SetCacheGTSMediaMaxSize safely sets the value for global configuration 'Cache.GTS.MediaMaxSize' field 3004 func SetCacheGTSMediaMaxSize(v int) { global.SetCacheGTSMediaMaxSize(v) } 3005 3006 // GetCacheGTSMediaTTL safely fetches the Configuration value for state's 'Cache.GTS.MediaTTL' field 3007 func (st *ConfigState) GetCacheGTSMediaTTL() (v time.Duration) { 3008 st.mutex.Lock() 3009 v = st.config.Cache.GTS.MediaTTL 3010 st.mutex.Unlock() 3011 return 3012 } 3013 3014 // SetCacheGTSMediaTTL safely sets the Configuration value for state's 'Cache.GTS.MediaTTL' field 3015 func (st *ConfigState) SetCacheGTSMediaTTL(v time.Duration) { 3016 st.mutex.Lock() 3017 defer st.mutex.Unlock() 3018 st.config.Cache.GTS.MediaTTL = v 3019 st.reloadToViper() 3020 } 3021 3022 // CacheGTSMediaTTLFlag returns the flag name for the 'Cache.GTS.MediaTTL' field 3023 func CacheGTSMediaTTLFlag() string { return "cache-gts-media-ttl" } 3024 3025 // GetCacheGTSMediaTTL safely fetches the value for global configuration 'Cache.GTS.MediaTTL' field 3026 func GetCacheGTSMediaTTL() time.Duration { return global.GetCacheGTSMediaTTL() } 3027 3028 // SetCacheGTSMediaTTL safely sets the value for global configuration 'Cache.GTS.MediaTTL' field 3029 func SetCacheGTSMediaTTL(v time.Duration) { global.SetCacheGTSMediaTTL(v) } 3030 3031 // GetCacheGTSMediaSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.MediaSweepFreq' field 3032 func (st *ConfigState) GetCacheGTSMediaSweepFreq() (v time.Duration) { 3033 st.mutex.Lock() 3034 v = st.config.Cache.GTS.MediaSweepFreq 3035 st.mutex.Unlock() 3036 return 3037 } 3038 3039 // SetCacheGTSMediaSweepFreq safely sets the Configuration value for state's 'Cache.GTS.MediaSweepFreq' field 3040 func (st *ConfigState) SetCacheGTSMediaSweepFreq(v time.Duration) { 3041 st.mutex.Lock() 3042 defer st.mutex.Unlock() 3043 st.config.Cache.GTS.MediaSweepFreq = v 3044 st.reloadToViper() 3045 } 3046 3047 // CacheGTSMediaSweepFreqFlag returns the flag name for the 'Cache.GTS.MediaSweepFreq' field 3048 func CacheGTSMediaSweepFreqFlag() string { return "cache-gts-media-sweep-freq" } 3049 3050 // GetCacheGTSMediaSweepFreq safely fetches the value for global configuration 'Cache.GTS.MediaSweepFreq' field 3051 func GetCacheGTSMediaSweepFreq() time.Duration { return global.GetCacheGTSMediaSweepFreq() } 3052 3053 // SetCacheGTSMediaSweepFreq safely sets the value for global configuration 'Cache.GTS.MediaSweepFreq' field 3054 func SetCacheGTSMediaSweepFreq(v time.Duration) { global.SetCacheGTSMediaSweepFreq(v) } 3055 3056 // GetCacheGTSMentionMaxSize safely fetches the Configuration value for state's 'Cache.GTS.MentionMaxSize' field 3057 func (st *ConfigState) GetCacheGTSMentionMaxSize() (v int) { 3058 st.mutex.Lock() 3059 v = st.config.Cache.GTS.MentionMaxSize 3060 st.mutex.Unlock() 3061 return 3062 } 3063 3064 // SetCacheGTSMentionMaxSize safely sets the Configuration value for state's 'Cache.GTS.MentionMaxSize' field 3065 func (st *ConfigState) SetCacheGTSMentionMaxSize(v int) { 3066 st.mutex.Lock() 3067 defer st.mutex.Unlock() 3068 st.config.Cache.GTS.MentionMaxSize = v 3069 st.reloadToViper() 3070 } 3071 3072 // CacheGTSMentionMaxSizeFlag returns the flag name for the 'Cache.GTS.MentionMaxSize' field 3073 func CacheGTSMentionMaxSizeFlag() string { return "cache-gts-mention-max-size" } 3074 3075 // GetCacheGTSMentionMaxSize safely fetches the value for global configuration 'Cache.GTS.MentionMaxSize' field 3076 func GetCacheGTSMentionMaxSize() int { return global.GetCacheGTSMentionMaxSize() } 3077 3078 // SetCacheGTSMentionMaxSize safely sets the value for global configuration 'Cache.GTS.MentionMaxSize' field 3079 func SetCacheGTSMentionMaxSize(v int) { global.SetCacheGTSMentionMaxSize(v) } 3080 3081 // GetCacheGTSMentionTTL safely fetches the Configuration value for state's 'Cache.GTS.MentionTTL' field 3082 func (st *ConfigState) GetCacheGTSMentionTTL() (v time.Duration) { 3083 st.mutex.Lock() 3084 v = st.config.Cache.GTS.MentionTTL 3085 st.mutex.Unlock() 3086 return 3087 } 3088 3089 // SetCacheGTSMentionTTL safely sets the Configuration value for state's 'Cache.GTS.MentionTTL' field 3090 func (st *ConfigState) SetCacheGTSMentionTTL(v time.Duration) { 3091 st.mutex.Lock() 3092 defer st.mutex.Unlock() 3093 st.config.Cache.GTS.MentionTTL = v 3094 st.reloadToViper() 3095 } 3096 3097 // CacheGTSMentionTTLFlag returns the flag name for the 'Cache.GTS.MentionTTL' field 3098 func CacheGTSMentionTTLFlag() string { return "cache-gts-mention-ttl" } 3099 3100 // GetCacheGTSMentionTTL safely fetches the value for global configuration 'Cache.GTS.MentionTTL' field 3101 func GetCacheGTSMentionTTL() time.Duration { return global.GetCacheGTSMentionTTL() } 3102 3103 // SetCacheGTSMentionTTL safely sets the value for global configuration 'Cache.GTS.MentionTTL' field 3104 func SetCacheGTSMentionTTL(v time.Duration) { global.SetCacheGTSMentionTTL(v) } 3105 3106 // GetCacheGTSMentionSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.MentionSweepFreq' field 3107 func (st *ConfigState) GetCacheGTSMentionSweepFreq() (v time.Duration) { 3108 st.mutex.Lock() 3109 v = st.config.Cache.GTS.MentionSweepFreq 3110 st.mutex.Unlock() 3111 return 3112 } 3113 3114 // SetCacheGTSMentionSweepFreq safely sets the Configuration value for state's 'Cache.GTS.MentionSweepFreq' field 3115 func (st *ConfigState) SetCacheGTSMentionSweepFreq(v time.Duration) { 3116 st.mutex.Lock() 3117 defer st.mutex.Unlock() 3118 st.config.Cache.GTS.MentionSweepFreq = v 3119 st.reloadToViper() 3120 } 3121 3122 // CacheGTSMentionSweepFreqFlag returns the flag name for the 'Cache.GTS.MentionSweepFreq' field 3123 func CacheGTSMentionSweepFreqFlag() string { return "cache-gts-mention-sweep-freq" } 3124 3125 // GetCacheGTSMentionSweepFreq safely fetches the value for global configuration 'Cache.GTS.MentionSweepFreq' field 3126 func GetCacheGTSMentionSweepFreq() time.Duration { return global.GetCacheGTSMentionSweepFreq() } 3127 3128 // SetCacheGTSMentionSweepFreq safely sets the value for global configuration 'Cache.GTS.MentionSweepFreq' field 3129 func SetCacheGTSMentionSweepFreq(v time.Duration) { global.SetCacheGTSMentionSweepFreq(v) } 3130 3131 // GetCacheGTSNotificationMaxSize safely fetches the Configuration value for state's 'Cache.GTS.NotificationMaxSize' field 3132 func (st *ConfigState) GetCacheGTSNotificationMaxSize() (v int) { 3133 st.mutex.Lock() 3134 v = st.config.Cache.GTS.NotificationMaxSize 3135 st.mutex.Unlock() 3136 return 3137 } 3138 3139 // SetCacheGTSNotificationMaxSize safely sets the Configuration value for state's 'Cache.GTS.NotificationMaxSize' field 3140 func (st *ConfigState) SetCacheGTSNotificationMaxSize(v int) { 3141 st.mutex.Lock() 3142 defer st.mutex.Unlock() 3143 st.config.Cache.GTS.NotificationMaxSize = v 3144 st.reloadToViper() 3145 } 3146 3147 // CacheGTSNotificationMaxSizeFlag returns the flag name for the 'Cache.GTS.NotificationMaxSize' field 3148 func CacheGTSNotificationMaxSizeFlag() string { return "cache-gts-notification-max-size" } 3149 3150 // GetCacheGTSNotificationMaxSize safely fetches the value for global configuration 'Cache.GTS.NotificationMaxSize' field 3151 func GetCacheGTSNotificationMaxSize() int { return global.GetCacheGTSNotificationMaxSize() } 3152 3153 // SetCacheGTSNotificationMaxSize safely sets the value for global configuration 'Cache.GTS.NotificationMaxSize' field 3154 func SetCacheGTSNotificationMaxSize(v int) { global.SetCacheGTSNotificationMaxSize(v) } 3155 3156 // GetCacheGTSNotificationTTL safely fetches the Configuration value for state's 'Cache.GTS.NotificationTTL' field 3157 func (st *ConfigState) GetCacheGTSNotificationTTL() (v time.Duration) { 3158 st.mutex.Lock() 3159 v = st.config.Cache.GTS.NotificationTTL 3160 st.mutex.Unlock() 3161 return 3162 } 3163 3164 // SetCacheGTSNotificationTTL safely sets the Configuration value for state's 'Cache.GTS.NotificationTTL' field 3165 func (st *ConfigState) SetCacheGTSNotificationTTL(v time.Duration) { 3166 st.mutex.Lock() 3167 defer st.mutex.Unlock() 3168 st.config.Cache.GTS.NotificationTTL = v 3169 st.reloadToViper() 3170 } 3171 3172 // CacheGTSNotificationTTLFlag returns the flag name for the 'Cache.GTS.NotificationTTL' field 3173 func CacheGTSNotificationTTLFlag() string { return "cache-gts-notification-ttl" } 3174 3175 // GetCacheGTSNotificationTTL safely fetches the value for global configuration 'Cache.GTS.NotificationTTL' field 3176 func GetCacheGTSNotificationTTL() time.Duration { return global.GetCacheGTSNotificationTTL() } 3177 3178 // SetCacheGTSNotificationTTL safely sets the value for global configuration 'Cache.GTS.NotificationTTL' field 3179 func SetCacheGTSNotificationTTL(v time.Duration) { global.SetCacheGTSNotificationTTL(v) } 3180 3181 // GetCacheGTSNotificationSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.NotificationSweepFreq' field 3182 func (st *ConfigState) GetCacheGTSNotificationSweepFreq() (v time.Duration) { 3183 st.mutex.Lock() 3184 v = st.config.Cache.GTS.NotificationSweepFreq 3185 st.mutex.Unlock() 3186 return 3187 } 3188 3189 // SetCacheGTSNotificationSweepFreq safely sets the Configuration value for state's 'Cache.GTS.NotificationSweepFreq' field 3190 func (st *ConfigState) SetCacheGTSNotificationSweepFreq(v time.Duration) { 3191 st.mutex.Lock() 3192 defer st.mutex.Unlock() 3193 st.config.Cache.GTS.NotificationSweepFreq = v 3194 st.reloadToViper() 3195 } 3196 3197 // CacheGTSNotificationSweepFreqFlag returns the flag name for the 'Cache.GTS.NotificationSweepFreq' field 3198 func CacheGTSNotificationSweepFreqFlag() string { return "cache-gts-notification-sweep-freq" } 3199 3200 // GetCacheGTSNotificationSweepFreq safely fetches the value for global configuration 'Cache.GTS.NotificationSweepFreq' field 3201 func GetCacheGTSNotificationSweepFreq() time.Duration { 3202 return global.GetCacheGTSNotificationSweepFreq() 3203 } 3204 3205 // SetCacheGTSNotificationSweepFreq safely sets the value for global configuration 'Cache.GTS.NotificationSweepFreq' field 3206 func SetCacheGTSNotificationSweepFreq(v time.Duration) { global.SetCacheGTSNotificationSweepFreq(v) } 3207 3208 // GetCacheGTSReportMaxSize safely fetches the Configuration value for state's 'Cache.GTS.ReportMaxSize' field 3209 func (st *ConfigState) GetCacheGTSReportMaxSize() (v int) { 3210 st.mutex.Lock() 3211 v = st.config.Cache.GTS.ReportMaxSize 3212 st.mutex.Unlock() 3213 return 3214 } 3215 3216 // SetCacheGTSReportMaxSize safely sets the Configuration value for state's 'Cache.GTS.ReportMaxSize' field 3217 func (st *ConfigState) SetCacheGTSReportMaxSize(v int) { 3218 st.mutex.Lock() 3219 defer st.mutex.Unlock() 3220 st.config.Cache.GTS.ReportMaxSize = v 3221 st.reloadToViper() 3222 } 3223 3224 // CacheGTSReportMaxSizeFlag returns the flag name for the 'Cache.GTS.ReportMaxSize' field 3225 func CacheGTSReportMaxSizeFlag() string { return "cache-gts-report-max-size" } 3226 3227 // GetCacheGTSReportMaxSize safely fetches the value for global configuration 'Cache.GTS.ReportMaxSize' field 3228 func GetCacheGTSReportMaxSize() int { return global.GetCacheGTSReportMaxSize() } 3229 3230 // SetCacheGTSReportMaxSize safely sets the value for global configuration 'Cache.GTS.ReportMaxSize' field 3231 func SetCacheGTSReportMaxSize(v int) { global.SetCacheGTSReportMaxSize(v) } 3232 3233 // GetCacheGTSReportTTL safely fetches the Configuration value for state's 'Cache.GTS.ReportTTL' field 3234 func (st *ConfigState) GetCacheGTSReportTTL() (v time.Duration) { 3235 st.mutex.Lock() 3236 v = st.config.Cache.GTS.ReportTTL 3237 st.mutex.Unlock() 3238 return 3239 } 3240 3241 // SetCacheGTSReportTTL safely sets the Configuration value for state's 'Cache.GTS.ReportTTL' field 3242 func (st *ConfigState) SetCacheGTSReportTTL(v time.Duration) { 3243 st.mutex.Lock() 3244 defer st.mutex.Unlock() 3245 st.config.Cache.GTS.ReportTTL = v 3246 st.reloadToViper() 3247 } 3248 3249 // CacheGTSReportTTLFlag returns the flag name for the 'Cache.GTS.ReportTTL' field 3250 func CacheGTSReportTTLFlag() string { return "cache-gts-report-ttl" } 3251 3252 // GetCacheGTSReportTTL safely fetches the value for global configuration 'Cache.GTS.ReportTTL' field 3253 func GetCacheGTSReportTTL() time.Duration { return global.GetCacheGTSReportTTL() } 3254 3255 // SetCacheGTSReportTTL safely sets the value for global configuration 'Cache.GTS.ReportTTL' field 3256 func SetCacheGTSReportTTL(v time.Duration) { global.SetCacheGTSReportTTL(v) } 3257 3258 // GetCacheGTSReportSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.ReportSweepFreq' field 3259 func (st *ConfigState) GetCacheGTSReportSweepFreq() (v time.Duration) { 3260 st.mutex.Lock() 3261 v = st.config.Cache.GTS.ReportSweepFreq 3262 st.mutex.Unlock() 3263 return 3264 } 3265 3266 // SetCacheGTSReportSweepFreq safely sets the Configuration value for state's 'Cache.GTS.ReportSweepFreq' field 3267 func (st *ConfigState) SetCacheGTSReportSweepFreq(v time.Duration) { 3268 st.mutex.Lock() 3269 defer st.mutex.Unlock() 3270 st.config.Cache.GTS.ReportSweepFreq = v 3271 st.reloadToViper() 3272 } 3273 3274 // CacheGTSReportSweepFreqFlag returns the flag name for the 'Cache.GTS.ReportSweepFreq' field 3275 func CacheGTSReportSweepFreqFlag() string { return "cache-gts-report-sweep-freq" } 3276 3277 // GetCacheGTSReportSweepFreq safely fetches the value for global configuration 'Cache.GTS.ReportSweepFreq' field 3278 func GetCacheGTSReportSweepFreq() time.Duration { return global.GetCacheGTSReportSweepFreq() } 3279 3280 // SetCacheGTSReportSweepFreq safely sets the value for global configuration 'Cache.GTS.ReportSweepFreq' field 3281 func SetCacheGTSReportSweepFreq(v time.Duration) { global.SetCacheGTSReportSweepFreq(v) } 3282 3283 // GetCacheGTSStatusMaxSize safely fetches the Configuration value for state's 'Cache.GTS.StatusMaxSize' field 3284 func (st *ConfigState) GetCacheGTSStatusMaxSize() (v int) { 3285 st.mutex.Lock() 3286 v = st.config.Cache.GTS.StatusMaxSize 3287 st.mutex.Unlock() 3288 return 3289 } 3290 3291 // SetCacheGTSStatusMaxSize safely sets the Configuration value for state's 'Cache.GTS.StatusMaxSize' field 3292 func (st *ConfigState) SetCacheGTSStatusMaxSize(v int) { 3293 st.mutex.Lock() 3294 defer st.mutex.Unlock() 3295 st.config.Cache.GTS.StatusMaxSize = v 3296 st.reloadToViper() 3297 } 3298 3299 // CacheGTSStatusMaxSizeFlag returns the flag name for the 'Cache.GTS.StatusMaxSize' field 3300 func CacheGTSStatusMaxSizeFlag() string { return "cache-gts-status-max-size" } 3301 3302 // GetCacheGTSStatusMaxSize safely fetches the value for global configuration 'Cache.GTS.StatusMaxSize' field 3303 func GetCacheGTSStatusMaxSize() int { return global.GetCacheGTSStatusMaxSize() } 3304 3305 // SetCacheGTSStatusMaxSize safely sets the value for global configuration 'Cache.GTS.StatusMaxSize' field 3306 func SetCacheGTSStatusMaxSize(v int) { global.SetCacheGTSStatusMaxSize(v) } 3307 3308 // GetCacheGTSStatusTTL safely fetches the Configuration value for state's 'Cache.GTS.StatusTTL' field 3309 func (st *ConfigState) GetCacheGTSStatusTTL() (v time.Duration) { 3310 st.mutex.Lock() 3311 v = st.config.Cache.GTS.StatusTTL 3312 st.mutex.Unlock() 3313 return 3314 } 3315 3316 // SetCacheGTSStatusTTL safely sets the Configuration value for state's 'Cache.GTS.StatusTTL' field 3317 func (st *ConfigState) SetCacheGTSStatusTTL(v time.Duration) { 3318 st.mutex.Lock() 3319 defer st.mutex.Unlock() 3320 st.config.Cache.GTS.StatusTTL = v 3321 st.reloadToViper() 3322 } 3323 3324 // CacheGTSStatusTTLFlag returns the flag name for the 'Cache.GTS.StatusTTL' field 3325 func CacheGTSStatusTTLFlag() string { return "cache-gts-status-ttl" } 3326 3327 // GetCacheGTSStatusTTL safely fetches the value for global configuration 'Cache.GTS.StatusTTL' field 3328 func GetCacheGTSStatusTTL() time.Duration { return global.GetCacheGTSStatusTTL() } 3329 3330 // SetCacheGTSStatusTTL safely sets the value for global configuration 'Cache.GTS.StatusTTL' field 3331 func SetCacheGTSStatusTTL(v time.Duration) { global.SetCacheGTSStatusTTL(v) } 3332 3333 // GetCacheGTSStatusSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.StatusSweepFreq' field 3334 func (st *ConfigState) GetCacheGTSStatusSweepFreq() (v time.Duration) { 3335 st.mutex.Lock() 3336 v = st.config.Cache.GTS.StatusSweepFreq 3337 st.mutex.Unlock() 3338 return 3339 } 3340 3341 // SetCacheGTSStatusSweepFreq safely sets the Configuration value for state's 'Cache.GTS.StatusSweepFreq' field 3342 func (st *ConfigState) SetCacheGTSStatusSweepFreq(v time.Duration) { 3343 st.mutex.Lock() 3344 defer st.mutex.Unlock() 3345 st.config.Cache.GTS.StatusSweepFreq = v 3346 st.reloadToViper() 3347 } 3348 3349 // CacheGTSStatusSweepFreqFlag returns the flag name for the 'Cache.GTS.StatusSweepFreq' field 3350 func CacheGTSStatusSweepFreqFlag() string { return "cache-gts-status-sweep-freq" } 3351 3352 // GetCacheGTSStatusSweepFreq safely fetches the value for global configuration 'Cache.GTS.StatusSweepFreq' field 3353 func GetCacheGTSStatusSweepFreq() time.Duration { return global.GetCacheGTSStatusSweepFreq() } 3354 3355 // SetCacheGTSStatusSweepFreq safely sets the value for global configuration 'Cache.GTS.StatusSweepFreq' field 3356 func SetCacheGTSStatusSweepFreq(v time.Duration) { global.SetCacheGTSStatusSweepFreq(v) } 3357 3358 // GetCacheGTSStatusFaveMaxSize safely fetches the Configuration value for state's 'Cache.GTS.StatusFaveMaxSize' field 3359 func (st *ConfigState) GetCacheGTSStatusFaveMaxSize() (v int) { 3360 st.mutex.Lock() 3361 v = st.config.Cache.GTS.StatusFaveMaxSize 3362 st.mutex.Unlock() 3363 return 3364 } 3365 3366 // SetCacheGTSStatusFaveMaxSize safely sets the Configuration value for state's 'Cache.GTS.StatusFaveMaxSize' field 3367 func (st *ConfigState) SetCacheGTSStatusFaveMaxSize(v int) { 3368 st.mutex.Lock() 3369 defer st.mutex.Unlock() 3370 st.config.Cache.GTS.StatusFaveMaxSize = v 3371 st.reloadToViper() 3372 } 3373 3374 // CacheGTSStatusFaveMaxSizeFlag returns the flag name for the 'Cache.GTS.StatusFaveMaxSize' field 3375 func CacheGTSStatusFaveMaxSizeFlag() string { return "cache-gts-status-fave-max-size" } 3376 3377 // GetCacheGTSStatusFaveMaxSize safely fetches the value for global configuration 'Cache.GTS.StatusFaveMaxSize' field 3378 func GetCacheGTSStatusFaveMaxSize() int { return global.GetCacheGTSStatusFaveMaxSize() } 3379 3380 // SetCacheGTSStatusFaveMaxSize safely sets the value for global configuration 'Cache.GTS.StatusFaveMaxSize' field 3381 func SetCacheGTSStatusFaveMaxSize(v int) { global.SetCacheGTSStatusFaveMaxSize(v) } 3382 3383 // GetCacheGTSStatusFaveTTL safely fetches the Configuration value for state's 'Cache.GTS.StatusFaveTTL' field 3384 func (st *ConfigState) GetCacheGTSStatusFaveTTL() (v time.Duration) { 3385 st.mutex.Lock() 3386 v = st.config.Cache.GTS.StatusFaveTTL 3387 st.mutex.Unlock() 3388 return 3389 } 3390 3391 // SetCacheGTSStatusFaveTTL safely sets the Configuration value for state's 'Cache.GTS.StatusFaveTTL' field 3392 func (st *ConfigState) SetCacheGTSStatusFaveTTL(v time.Duration) { 3393 st.mutex.Lock() 3394 defer st.mutex.Unlock() 3395 st.config.Cache.GTS.StatusFaveTTL = v 3396 st.reloadToViper() 3397 } 3398 3399 // CacheGTSStatusFaveTTLFlag returns the flag name for the 'Cache.GTS.StatusFaveTTL' field 3400 func CacheGTSStatusFaveTTLFlag() string { return "cache-gts-status-fave-ttl" } 3401 3402 // GetCacheGTSStatusFaveTTL safely fetches the value for global configuration 'Cache.GTS.StatusFaveTTL' field 3403 func GetCacheGTSStatusFaveTTL() time.Duration { return global.GetCacheGTSStatusFaveTTL() } 3404 3405 // SetCacheGTSStatusFaveTTL safely sets the value for global configuration 'Cache.GTS.StatusFaveTTL' field 3406 func SetCacheGTSStatusFaveTTL(v time.Duration) { global.SetCacheGTSStatusFaveTTL(v) } 3407 3408 // GetCacheGTSStatusFaveSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.StatusFaveSweepFreq' field 3409 func (st *ConfigState) GetCacheGTSStatusFaveSweepFreq() (v time.Duration) { 3410 st.mutex.Lock() 3411 v = st.config.Cache.GTS.StatusFaveSweepFreq 3412 st.mutex.Unlock() 3413 return 3414 } 3415 3416 // SetCacheGTSStatusFaveSweepFreq safely sets the Configuration value for state's 'Cache.GTS.StatusFaveSweepFreq' field 3417 func (st *ConfigState) SetCacheGTSStatusFaveSweepFreq(v time.Duration) { 3418 st.mutex.Lock() 3419 defer st.mutex.Unlock() 3420 st.config.Cache.GTS.StatusFaveSweepFreq = v 3421 st.reloadToViper() 3422 } 3423 3424 // CacheGTSStatusFaveSweepFreqFlag returns the flag name for the 'Cache.GTS.StatusFaveSweepFreq' field 3425 func CacheGTSStatusFaveSweepFreqFlag() string { return "cache-gts-status-fave-sweep-freq" } 3426 3427 // GetCacheGTSStatusFaveSweepFreq safely fetches the value for global configuration 'Cache.GTS.StatusFaveSweepFreq' field 3428 func GetCacheGTSStatusFaveSweepFreq() time.Duration { return global.GetCacheGTSStatusFaveSweepFreq() } 3429 3430 // SetCacheGTSStatusFaveSweepFreq safely sets the value for global configuration 'Cache.GTS.StatusFaveSweepFreq' field 3431 func SetCacheGTSStatusFaveSweepFreq(v time.Duration) { global.SetCacheGTSStatusFaveSweepFreq(v) } 3432 3433 // GetCacheGTSTombstoneMaxSize safely fetches the Configuration value for state's 'Cache.GTS.TombstoneMaxSize' field 3434 func (st *ConfigState) GetCacheGTSTombstoneMaxSize() (v int) { 3435 st.mutex.Lock() 3436 v = st.config.Cache.GTS.TombstoneMaxSize 3437 st.mutex.Unlock() 3438 return 3439 } 3440 3441 // SetCacheGTSTombstoneMaxSize safely sets the Configuration value for state's 'Cache.GTS.TombstoneMaxSize' field 3442 func (st *ConfigState) SetCacheGTSTombstoneMaxSize(v int) { 3443 st.mutex.Lock() 3444 defer st.mutex.Unlock() 3445 st.config.Cache.GTS.TombstoneMaxSize = v 3446 st.reloadToViper() 3447 } 3448 3449 // CacheGTSTombstoneMaxSizeFlag returns the flag name for the 'Cache.GTS.TombstoneMaxSize' field 3450 func CacheGTSTombstoneMaxSizeFlag() string { return "cache-gts-tombstone-max-size" } 3451 3452 // GetCacheGTSTombstoneMaxSize safely fetches the value for global configuration 'Cache.GTS.TombstoneMaxSize' field 3453 func GetCacheGTSTombstoneMaxSize() int { return global.GetCacheGTSTombstoneMaxSize() } 3454 3455 // SetCacheGTSTombstoneMaxSize safely sets the value for global configuration 'Cache.GTS.TombstoneMaxSize' field 3456 func SetCacheGTSTombstoneMaxSize(v int) { global.SetCacheGTSTombstoneMaxSize(v) } 3457 3458 // GetCacheGTSTombstoneTTL safely fetches the Configuration value for state's 'Cache.GTS.TombstoneTTL' field 3459 func (st *ConfigState) GetCacheGTSTombstoneTTL() (v time.Duration) { 3460 st.mutex.Lock() 3461 v = st.config.Cache.GTS.TombstoneTTL 3462 st.mutex.Unlock() 3463 return 3464 } 3465 3466 // SetCacheGTSTombstoneTTL safely sets the Configuration value for state's 'Cache.GTS.TombstoneTTL' field 3467 func (st *ConfigState) SetCacheGTSTombstoneTTL(v time.Duration) { 3468 st.mutex.Lock() 3469 defer st.mutex.Unlock() 3470 st.config.Cache.GTS.TombstoneTTL = v 3471 st.reloadToViper() 3472 } 3473 3474 // CacheGTSTombstoneTTLFlag returns the flag name for the 'Cache.GTS.TombstoneTTL' field 3475 func CacheGTSTombstoneTTLFlag() string { return "cache-gts-tombstone-ttl" } 3476 3477 // GetCacheGTSTombstoneTTL safely fetches the value for global configuration 'Cache.GTS.TombstoneTTL' field 3478 func GetCacheGTSTombstoneTTL() time.Duration { return global.GetCacheGTSTombstoneTTL() } 3479 3480 // SetCacheGTSTombstoneTTL safely sets the value for global configuration 'Cache.GTS.TombstoneTTL' field 3481 func SetCacheGTSTombstoneTTL(v time.Duration) { global.SetCacheGTSTombstoneTTL(v) } 3482 3483 // GetCacheGTSTombstoneSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.TombstoneSweepFreq' field 3484 func (st *ConfigState) GetCacheGTSTombstoneSweepFreq() (v time.Duration) { 3485 st.mutex.Lock() 3486 v = st.config.Cache.GTS.TombstoneSweepFreq 3487 st.mutex.Unlock() 3488 return 3489 } 3490 3491 // SetCacheGTSTombstoneSweepFreq safely sets the Configuration value for state's 'Cache.GTS.TombstoneSweepFreq' field 3492 func (st *ConfigState) SetCacheGTSTombstoneSweepFreq(v time.Duration) { 3493 st.mutex.Lock() 3494 defer st.mutex.Unlock() 3495 st.config.Cache.GTS.TombstoneSweepFreq = v 3496 st.reloadToViper() 3497 } 3498 3499 // CacheGTSTombstoneSweepFreqFlag returns the flag name for the 'Cache.GTS.TombstoneSweepFreq' field 3500 func CacheGTSTombstoneSweepFreqFlag() string { return "cache-gts-tombstone-sweep-freq" } 3501 3502 // GetCacheGTSTombstoneSweepFreq safely fetches the value for global configuration 'Cache.GTS.TombstoneSweepFreq' field 3503 func GetCacheGTSTombstoneSweepFreq() time.Duration { return global.GetCacheGTSTombstoneSweepFreq() } 3504 3505 // SetCacheGTSTombstoneSweepFreq safely sets the value for global configuration 'Cache.GTS.TombstoneSweepFreq' field 3506 func SetCacheGTSTombstoneSweepFreq(v time.Duration) { global.SetCacheGTSTombstoneSweepFreq(v) } 3507 3508 // GetCacheGTSUserMaxSize safely fetches the Configuration value for state's 'Cache.GTS.UserMaxSize' field 3509 func (st *ConfigState) GetCacheGTSUserMaxSize() (v int) { 3510 st.mutex.Lock() 3511 v = st.config.Cache.GTS.UserMaxSize 3512 st.mutex.Unlock() 3513 return 3514 } 3515 3516 // SetCacheGTSUserMaxSize safely sets the Configuration value for state's 'Cache.GTS.UserMaxSize' field 3517 func (st *ConfigState) SetCacheGTSUserMaxSize(v int) { 3518 st.mutex.Lock() 3519 defer st.mutex.Unlock() 3520 st.config.Cache.GTS.UserMaxSize = v 3521 st.reloadToViper() 3522 } 3523 3524 // CacheGTSUserMaxSizeFlag returns the flag name for the 'Cache.GTS.UserMaxSize' field 3525 func CacheGTSUserMaxSizeFlag() string { return "cache-gts-user-max-size" } 3526 3527 // GetCacheGTSUserMaxSize safely fetches the value for global configuration 'Cache.GTS.UserMaxSize' field 3528 func GetCacheGTSUserMaxSize() int { return global.GetCacheGTSUserMaxSize() } 3529 3530 // SetCacheGTSUserMaxSize safely sets the value for global configuration 'Cache.GTS.UserMaxSize' field 3531 func SetCacheGTSUserMaxSize(v int) { global.SetCacheGTSUserMaxSize(v) } 3532 3533 // GetCacheGTSUserTTL safely fetches the Configuration value for state's 'Cache.GTS.UserTTL' field 3534 func (st *ConfigState) GetCacheGTSUserTTL() (v time.Duration) { 3535 st.mutex.Lock() 3536 v = st.config.Cache.GTS.UserTTL 3537 st.mutex.Unlock() 3538 return 3539 } 3540 3541 // SetCacheGTSUserTTL safely sets the Configuration value for state's 'Cache.GTS.UserTTL' field 3542 func (st *ConfigState) SetCacheGTSUserTTL(v time.Duration) { 3543 st.mutex.Lock() 3544 defer st.mutex.Unlock() 3545 st.config.Cache.GTS.UserTTL = v 3546 st.reloadToViper() 3547 } 3548 3549 // CacheGTSUserTTLFlag returns the flag name for the 'Cache.GTS.UserTTL' field 3550 func CacheGTSUserTTLFlag() string { return "cache-gts-user-ttl" } 3551 3552 // GetCacheGTSUserTTL safely fetches the value for global configuration 'Cache.GTS.UserTTL' field 3553 func GetCacheGTSUserTTL() time.Duration { return global.GetCacheGTSUserTTL() } 3554 3555 // SetCacheGTSUserTTL safely sets the value for global configuration 'Cache.GTS.UserTTL' field 3556 func SetCacheGTSUserTTL(v time.Duration) { global.SetCacheGTSUserTTL(v) } 3557 3558 // GetCacheGTSUserSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.UserSweepFreq' field 3559 func (st *ConfigState) GetCacheGTSUserSweepFreq() (v time.Duration) { 3560 st.mutex.Lock() 3561 v = st.config.Cache.GTS.UserSweepFreq 3562 st.mutex.Unlock() 3563 return 3564 } 3565 3566 // SetCacheGTSUserSweepFreq safely sets the Configuration value for state's 'Cache.GTS.UserSweepFreq' field 3567 func (st *ConfigState) SetCacheGTSUserSweepFreq(v time.Duration) { 3568 st.mutex.Lock() 3569 defer st.mutex.Unlock() 3570 st.config.Cache.GTS.UserSweepFreq = v 3571 st.reloadToViper() 3572 } 3573 3574 // CacheGTSUserSweepFreqFlag returns the flag name for the 'Cache.GTS.UserSweepFreq' field 3575 func CacheGTSUserSweepFreqFlag() string { return "cache-gts-user-sweep-freq" } 3576 3577 // GetCacheGTSUserSweepFreq safely fetches the value for global configuration 'Cache.GTS.UserSweepFreq' field 3578 func GetCacheGTSUserSweepFreq() time.Duration { return global.GetCacheGTSUserSweepFreq() } 3579 3580 // SetCacheGTSUserSweepFreq safely sets the value for global configuration 'Cache.GTS.UserSweepFreq' field 3581 func SetCacheGTSUserSweepFreq(v time.Duration) { global.SetCacheGTSUserSweepFreq(v) } 3582 3583 // GetCacheGTSWebfingerMaxSize safely fetches the Configuration value for state's 'Cache.GTS.WebfingerMaxSize' field 3584 func (st *ConfigState) GetCacheGTSWebfingerMaxSize() (v int) { 3585 st.mutex.Lock() 3586 v = st.config.Cache.GTS.WebfingerMaxSize 3587 st.mutex.Unlock() 3588 return 3589 } 3590 3591 // SetCacheGTSWebfingerMaxSize safely sets the Configuration value for state's 'Cache.GTS.WebfingerMaxSize' field 3592 func (st *ConfigState) SetCacheGTSWebfingerMaxSize(v int) { 3593 st.mutex.Lock() 3594 defer st.mutex.Unlock() 3595 st.config.Cache.GTS.WebfingerMaxSize = v 3596 st.reloadToViper() 3597 } 3598 3599 // CacheGTSWebfingerMaxSizeFlag returns the flag name for the 'Cache.GTS.WebfingerMaxSize' field 3600 func CacheGTSWebfingerMaxSizeFlag() string { return "cache-gts-webfinger-max-size" } 3601 3602 // GetCacheGTSWebfingerMaxSize safely fetches the value for global configuration 'Cache.GTS.WebfingerMaxSize' field 3603 func GetCacheGTSWebfingerMaxSize() int { return global.GetCacheGTSWebfingerMaxSize() } 3604 3605 // SetCacheGTSWebfingerMaxSize safely sets the value for global configuration 'Cache.GTS.WebfingerMaxSize' field 3606 func SetCacheGTSWebfingerMaxSize(v int) { global.SetCacheGTSWebfingerMaxSize(v) } 3607 3608 // GetCacheGTSWebfingerTTL safely fetches the Configuration value for state's 'Cache.GTS.WebfingerTTL' field 3609 func (st *ConfigState) GetCacheGTSWebfingerTTL() (v time.Duration) { 3610 st.mutex.Lock() 3611 v = st.config.Cache.GTS.WebfingerTTL 3612 st.mutex.Unlock() 3613 return 3614 } 3615 3616 // SetCacheGTSWebfingerTTL safely sets the Configuration value for state's 'Cache.GTS.WebfingerTTL' field 3617 func (st *ConfigState) SetCacheGTSWebfingerTTL(v time.Duration) { 3618 st.mutex.Lock() 3619 defer st.mutex.Unlock() 3620 st.config.Cache.GTS.WebfingerTTL = v 3621 st.reloadToViper() 3622 } 3623 3624 // CacheGTSWebfingerTTLFlag returns the flag name for the 'Cache.GTS.WebfingerTTL' field 3625 func CacheGTSWebfingerTTLFlag() string { return "cache-gts-webfinger-ttl" } 3626 3627 // GetCacheGTSWebfingerTTL safely fetches the value for global configuration 'Cache.GTS.WebfingerTTL' field 3628 func GetCacheGTSWebfingerTTL() time.Duration { return global.GetCacheGTSWebfingerTTL() } 3629 3630 // SetCacheGTSWebfingerTTL safely sets the value for global configuration 'Cache.GTS.WebfingerTTL' field 3631 func SetCacheGTSWebfingerTTL(v time.Duration) { global.SetCacheGTSWebfingerTTL(v) } 3632 3633 // GetCacheGTSWebfingerSweepFreq safely fetches the Configuration value for state's 'Cache.GTS.WebfingerSweepFreq' field 3634 func (st *ConfigState) GetCacheGTSWebfingerSweepFreq() (v time.Duration) { 3635 st.mutex.Lock() 3636 v = st.config.Cache.GTS.WebfingerSweepFreq 3637 st.mutex.Unlock() 3638 return 3639 } 3640 3641 // SetCacheGTSWebfingerSweepFreq safely sets the Configuration value for state's 'Cache.GTS.WebfingerSweepFreq' field 3642 func (st *ConfigState) SetCacheGTSWebfingerSweepFreq(v time.Duration) { 3643 st.mutex.Lock() 3644 defer st.mutex.Unlock() 3645 st.config.Cache.GTS.WebfingerSweepFreq = v 3646 st.reloadToViper() 3647 } 3648 3649 // CacheGTSWebfingerSweepFreqFlag returns the flag name for the 'Cache.GTS.WebfingerSweepFreq' field 3650 func CacheGTSWebfingerSweepFreqFlag() string { return "cache-gts-webfinger-sweep-freq" } 3651 3652 // GetCacheGTSWebfingerSweepFreq safely fetches the value for global configuration 'Cache.GTS.WebfingerSweepFreq' field 3653 func GetCacheGTSWebfingerSweepFreq() time.Duration { return global.GetCacheGTSWebfingerSweepFreq() } 3654 3655 // SetCacheGTSWebfingerSweepFreq safely sets the value for global configuration 'Cache.GTS.WebfingerSweepFreq' field 3656 func SetCacheGTSWebfingerSweepFreq(v time.Duration) { global.SetCacheGTSWebfingerSweepFreq(v) } 3657 3658 // GetCacheVisibilityMaxSize safely fetches the Configuration value for state's 'Cache.VisibilityMaxSize' field 3659 func (st *ConfigState) GetCacheVisibilityMaxSize() (v int) { 3660 st.mutex.Lock() 3661 v = st.config.Cache.VisibilityMaxSize 3662 st.mutex.Unlock() 3663 return 3664 } 3665 3666 // SetCacheVisibilityMaxSize safely sets the Configuration value for state's 'Cache.VisibilityMaxSize' field 3667 func (st *ConfigState) SetCacheVisibilityMaxSize(v int) { 3668 st.mutex.Lock() 3669 defer st.mutex.Unlock() 3670 st.config.Cache.VisibilityMaxSize = v 3671 st.reloadToViper() 3672 } 3673 3674 // CacheVisibilityMaxSizeFlag returns the flag name for the 'Cache.VisibilityMaxSize' field 3675 func CacheVisibilityMaxSizeFlag() string { return "cache-visibility-max-size" } 3676 3677 // GetCacheVisibilityMaxSize safely fetches the value for global configuration 'Cache.VisibilityMaxSize' field 3678 func GetCacheVisibilityMaxSize() int { return global.GetCacheVisibilityMaxSize() } 3679 3680 // SetCacheVisibilityMaxSize safely sets the value for global configuration 'Cache.VisibilityMaxSize' field 3681 func SetCacheVisibilityMaxSize(v int) { global.SetCacheVisibilityMaxSize(v) } 3682 3683 // GetCacheVisibilityTTL safely fetches the Configuration value for state's 'Cache.VisibilityTTL' field 3684 func (st *ConfigState) GetCacheVisibilityTTL() (v time.Duration) { 3685 st.mutex.Lock() 3686 v = st.config.Cache.VisibilityTTL 3687 st.mutex.Unlock() 3688 return 3689 } 3690 3691 // SetCacheVisibilityTTL safely sets the Configuration value for state's 'Cache.VisibilityTTL' field 3692 func (st *ConfigState) SetCacheVisibilityTTL(v time.Duration) { 3693 st.mutex.Lock() 3694 defer st.mutex.Unlock() 3695 st.config.Cache.VisibilityTTL = v 3696 st.reloadToViper() 3697 } 3698 3699 // CacheVisibilityTTLFlag returns the flag name for the 'Cache.VisibilityTTL' field 3700 func CacheVisibilityTTLFlag() string { return "cache-visibility-ttl" } 3701 3702 // GetCacheVisibilityTTL safely fetches the value for global configuration 'Cache.VisibilityTTL' field 3703 func GetCacheVisibilityTTL() time.Duration { return global.GetCacheVisibilityTTL() } 3704 3705 // SetCacheVisibilityTTL safely sets the value for global configuration 'Cache.VisibilityTTL' field 3706 func SetCacheVisibilityTTL(v time.Duration) { global.SetCacheVisibilityTTL(v) } 3707 3708 // GetCacheVisibilitySweepFreq safely fetches the Configuration value for state's 'Cache.VisibilitySweepFreq' field 3709 func (st *ConfigState) GetCacheVisibilitySweepFreq() (v time.Duration) { 3710 st.mutex.Lock() 3711 v = st.config.Cache.VisibilitySweepFreq 3712 st.mutex.Unlock() 3713 return 3714 } 3715 3716 // SetCacheVisibilitySweepFreq safely sets the Configuration value for state's 'Cache.VisibilitySweepFreq' field 3717 func (st *ConfigState) SetCacheVisibilitySweepFreq(v time.Duration) { 3718 st.mutex.Lock() 3719 defer st.mutex.Unlock() 3720 st.config.Cache.VisibilitySweepFreq = v 3721 st.reloadToViper() 3722 } 3723 3724 // CacheVisibilitySweepFreqFlag returns the flag name for the 'Cache.VisibilitySweepFreq' field 3725 func CacheVisibilitySweepFreqFlag() string { return "cache-visibility-sweep-freq" } 3726 3727 // GetCacheVisibilitySweepFreq safely fetches the value for global configuration 'Cache.VisibilitySweepFreq' field 3728 func GetCacheVisibilitySweepFreq() time.Duration { return global.GetCacheVisibilitySweepFreq() } 3729 3730 // SetCacheVisibilitySweepFreq safely sets the value for global configuration 'Cache.VisibilitySweepFreq' field 3731 func SetCacheVisibilitySweepFreq(v time.Duration) { global.SetCacheVisibilitySweepFreq(v) } 3732 3733 // GetAdminAccountUsername safely fetches the Configuration value for state's 'AdminAccountUsername' field 3734 func (st *ConfigState) GetAdminAccountUsername() (v string) { 3735 st.mutex.Lock() 3736 v = st.config.AdminAccountUsername 3737 st.mutex.Unlock() 3738 return 3739 } 3740 3741 // SetAdminAccountUsername safely sets the Configuration value for state's 'AdminAccountUsername' field 3742 func (st *ConfigState) SetAdminAccountUsername(v string) { 3743 st.mutex.Lock() 3744 defer st.mutex.Unlock() 3745 st.config.AdminAccountUsername = v 3746 st.reloadToViper() 3747 } 3748 3749 // AdminAccountUsernameFlag returns the flag name for the 'AdminAccountUsername' field 3750 func AdminAccountUsernameFlag() string { return "username" } 3751 3752 // GetAdminAccountUsername safely fetches the value for global configuration 'AdminAccountUsername' field 3753 func GetAdminAccountUsername() string { return global.GetAdminAccountUsername() } 3754 3755 // SetAdminAccountUsername safely sets the value for global configuration 'AdminAccountUsername' field 3756 func SetAdminAccountUsername(v string) { global.SetAdminAccountUsername(v) } 3757 3758 // GetAdminAccountEmail safely fetches the Configuration value for state's 'AdminAccountEmail' field 3759 func (st *ConfigState) GetAdminAccountEmail() (v string) { 3760 st.mutex.Lock() 3761 v = st.config.AdminAccountEmail 3762 st.mutex.Unlock() 3763 return 3764 } 3765 3766 // SetAdminAccountEmail safely sets the Configuration value for state's 'AdminAccountEmail' field 3767 func (st *ConfigState) SetAdminAccountEmail(v string) { 3768 st.mutex.Lock() 3769 defer st.mutex.Unlock() 3770 st.config.AdminAccountEmail = v 3771 st.reloadToViper() 3772 } 3773 3774 // AdminAccountEmailFlag returns the flag name for the 'AdminAccountEmail' field 3775 func AdminAccountEmailFlag() string { return "email" } 3776 3777 // GetAdminAccountEmail safely fetches the value for global configuration 'AdminAccountEmail' field 3778 func GetAdminAccountEmail() string { return global.GetAdminAccountEmail() } 3779 3780 // SetAdminAccountEmail safely sets the value for global configuration 'AdminAccountEmail' field 3781 func SetAdminAccountEmail(v string) { global.SetAdminAccountEmail(v) } 3782 3783 // GetAdminAccountPassword safely fetches the Configuration value for state's 'AdminAccountPassword' field 3784 func (st *ConfigState) GetAdminAccountPassword() (v string) { 3785 st.mutex.Lock() 3786 v = st.config.AdminAccountPassword 3787 st.mutex.Unlock() 3788 return 3789 } 3790 3791 // SetAdminAccountPassword safely sets the Configuration value for state's 'AdminAccountPassword' field 3792 func (st *ConfigState) SetAdminAccountPassword(v string) { 3793 st.mutex.Lock() 3794 defer st.mutex.Unlock() 3795 st.config.AdminAccountPassword = v 3796 st.reloadToViper() 3797 } 3798 3799 // AdminAccountPasswordFlag returns the flag name for the 'AdminAccountPassword' field 3800 func AdminAccountPasswordFlag() string { return "password" } 3801 3802 // GetAdminAccountPassword safely fetches the value for global configuration 'AdminAccountPassword' field 3803 func GetAdminAccountPassword() string { return global.GetAdminAccountPassword() } 3804 3805 // SetAdminAccountPassword safely sets the value for global configuration 'AdminAccountPassword' field 3806 func SetAdminAccountPassword(v string) { global.SetAdminAccountPassword(v) } 3807 3808 // GetAdminTransPath safely fetches the Configuration value for state's 'AdminTransPath' field 3809 func (st *ConfigState) GetAdminTransPath() (v string) { 3810 st.mutex.Lock() 3811 v = st.config.AdminTransPath 3812 st.mutex.Unlock() 3813 return 3814 } 3815 3816 // SetAdminTransPath safely sets the Configuration value for state's 'AdminTransPath' field 3817 func (st *ConfigState) SetAdminTransPath(v string) { 3818 st.mutex.Lock() 3819 defer st.mutex.Unlock() 3820 st.config.AdminTransPath = v 3821 st.reloadToViper() 3822 } 3823 3824 // AdminTransPathFlag returns the flag name for the 'AdminTransPath' field 3825 func AdminTransPathFlag() string { return "path" } 3826 3827 // GetAdminTransPath safely fetches the value for global configuration 'AdminTransPath' field 3828 func GetAdminTransPath() string { return global.GetAdminTransPath() } 3829 3830 // SetAdminTransPath safely sets the value for global configuration 'AdminTransPath' field 3831 func SetAdminTransPath(v string) { global.SetAdminTransPath(v) } 3832 3833 // GetAdminMediaPruneDryRun safely fetches the Configuration value for state's 'AdminMediaPruneDryRun' field 3834 func (st *ConfigState) GetAdminMediaPruneDryRun() (v bool) { 3835 st.mutex.Lock() 3836 v = st.config.AdminMediaPruneDryRun 3837 st.mutex.Unlock() 3838 return 3839 } 3840 3841 // SetAdminMediaPruneDryRun safely sets the Configuration value for state's 'AdminMediaPruneDryRun' field 3842 func (st *ConfigState) SetAdminMediaPruneDryRun(v bool) { 3843 st.mutex.Lock() 3844 defer st.mutex.Unlock() 3845 st.config.AdminMediaPruneDryRun = v 3846 st.reloadToViper() 3847 } 3848 3849 // AdminMediaPruneDryRunFlag returns the flag name for the 'AdminMediaPruneDryRun' field 3850 func AdminMediaPruneDryRunFlag() string { return "dry-run" } 3851 3852 // GetAdminMediaPruneDryRun safely fetches the value for global configuration 'AdminMediaPruneDryRun' field 3853 func GetAdminMediaPruneDryRun() bool { return global.GetAdminMediaPruneDryRun() } 3854 3855 // SetAdminMediaPruneDryRun safely sets the value for global configuration 'AdminMediaPruneDryRun' field 3856 func SetAdminMediaPruneDryRun(v bool) { global.SetAdminMediaPruneDryRun(v) } 3857 3858 // GetRequestIDHeader safely fetches the Configuration value for state's 'RequestIDHeader' field 3859 func (st *ConfigState) GetRequestIDHeader() (v string) { 3860 st.mutex.Lock() 3861 v = st.config.RequestIDHeader 3862 st.mutex.Unlock() 3863 return 3864 } 3865 3866 // SetRequestIDHeader safely sets the Configuration value for state's 'RequestIDHeader' field 3867 func (st *ConfigState) SetRequestIDHeader(v string) { 3868 st.mutex.Lock() 3869 defer st.mutex.Unlock() 3870 st.config.RequestIDHeader = v 3871 st.reloadToViper() 3872 } 3873 3874 // RequestIDHeaderFlag returns the flag name for the 'RequestIDHeader' field 3875 func RequestIDHeaderFlag() string { return "request-id-header" } 3876 3877 // GetRequestIDHeader safely fetches the value for global configuration 'RequestIDHeader' field 3878 func GetRequestIDHeader() string { return global.GetRequestIDHeader() } 3879 3880 // SetRequestIDHeader safely sets the value for global configuration 'RequestIDHeader' field 3881 func SetRequestIDHeader(v string) { global.SetRequestIDHeader(v) }