cypress

package module

Go to main page

Versions in this module

v1

v1.4.13

Oct 11, 2023

v1.4.12

Aug 30, 2022

v1.4.11

Aug 5, 2022

Changes in this version

+ func Max(v1, v2 T) T

+ func Min(v1, v2 T) T

v1.4.10

Jul 1, 2022

Changes in this version

type PageQuery

+ func (q *PageQuery[T, TPrimaryKey, TSecondaryKey]) DoQueryWithCustomPageToken(ctx context.Context, paging, pagingToken string, pageSize int, ...) (*DataPage[*T], error)

v1.4.9

Jun 29, 2022

Changes in this version

+ const PagingNext

+ const PagingNone

+ const PagingPrev

+ func OrderedCompare(lh T, rh T) int

+ type Complex interface

+ type DataPage struct

+ Page int

+ PageToken string

+ Records []T

+ Summary interface{}

+ TotalPages int

+ TotalRecords int64

+ type Float interface

+ type Integer interface

+ type Ordered interface

+ type PageQuery struct

+ Cluster *MyCluster

+ CountingQueryArgsConfigurer func() []interface{}

+ CountingQueryText string

+ PrimaryKeyComparer Comparer[TPrimaryKey]

+ PrimaryKeyGetter func(t *T) TPrimaryKey

+ PrimaryKeyName string

+ PrimaryKeyParser func(value string) (TPrimaryKey, bool)

+ QuerySetup func(sql *strings.Builder) ([]interface{}, bool)

+ SecondaryKeyComparer Comparer[TSecondaryKey]

+ SecondaryKeyGetter func(t *T) TSecondaryKey

+ SecondaryKeyName string

+ SecondaryKeyParser func(value string) (TSecondaryKey, bool)

+ func (q *PageQuery[T, TPrimaryKey, TSecondaryKey]) DoQuery(ctx context.Context, paging, pagingToken string, pageSize int) (*DataPage[*T], error)

+ type Signed interface

+ type Stringify interface

+ String func() string

+ type Unsigned interface

v1.4.8

May 28, 2022

Changes in this version

+ const BackupKeyNameSuffix

+ const ClusterTxnStateCommitted

+ const ClusterTxnStateNone

+ const ClusterTxnStateRollback

+ const DefaultJwtProviderName

+ const EntityTagsAlias

+ const EntityTagsCol

+ const EntityTagsDTags

+ const EntityTagsDTagsAutoInc

+ const EntityTagsDTagsKey

+ const EntityTagsDTagsMultiKey

+ const EntityTagsDTagsNoGen

+ const EntityTagsDTagsNoUpdate

+ const EntityTagsDTagsPartition

+ const EntityTagsDTagsSecure

+ const EntityTagsPrefix

+ const MaxPooledID

+ const MaxSegmentedID

+ const PartitionKeyBitWidth

+ const PartitionKeyMask

+ const PooledIDBitWidth

+ const SegmentedIDBitWidth

+ const SegmentedIDMask

+ const SessionKey

+ const TraceActivityIDKey

+ const UserPrincipalKey

+ const XAStateActive

+ const XAStateCommitted

+ const XAStateIdle

+ const XAStatePrepared

+ const XAStateRollback

+ const XAStateUnknown

+ var CaptchaKey = "captcha"

+ var CaptchaSessionKey = "sessid"

+ var CorrelationIDHeader = http.CanonicalHeaderKey("x-correlation-id")

+ var EntityToTableNameMapper = TableNameResolverFunc(ToSnakeCase)

+ var ErrBadSessionFile = errors.New("bad session file")

+ var ErrDirectoryRequired = errors.New("a directory is required")

+ var ErrDupActionName = errors.New("action name duplicated")

+ var ErrFileRequired = errors.New("a file is required")

+ var ErrLockCancelled = errors.New("context cancelled before lock is acquired")

+ var ErrLockFailed = errors.New("failed to lock")

+ var ErrNoFile = errors.New("no template file")

+ var ErrOutOfRange = errors.New("value out of range")

+ var ErrPointerRequired = errors.New("a pointer is required")

+ var ErrSessionNotFound = errors.New("session not found")

+ var NotFoundMsg = "Sorry, we are not able to find the resource you requested"

+ var SQLIdentifierQuoteLeft = "`"

+ var SQLIdentifierQuoteRight = "`"

+ var ServerName = "cypress"

+ var ServerVersion = "v0.1.1110"

+ var SkinDefault = "default"

+ var ZkLock2MaxConcurrentThreads int64 = int64(math.MaxInt32) / 2

+ func AccessorGetOne(ctx context.Context, accessor *DbAccessor, proto *T) (*T, error)

+ func AccessorGetOneByKey(ctx context.Context, accessor *DbAccessor, key interface{}) (*T, error)

+ func AccessorQueryAll(ctx context.Context, accessor *DbAccessor, sql string, mapper RowMapper, ...) ([]*T, error)

+ func AccessorQueryOne(ctx context.Context, accessor *DbAccessor, sql string, mapper RowMapper, ...) (*T, error)

+ func Aes256Decrypt(key, iv, data []byte) ([]byte, error)

+ func Aes256Encrypt(key, iv, data []byte) ([]byte, error)

+ func CalculateMd5PartitionKey(key string) int32

+ func CalculateMd5PartitionKey2(key string) int32

+ func ClusterGetAll(ctx context.Context, cluster *MyCluster, query string, args ...interface{}) ([][]*T, error)

+ func ClusterGetOne(ctx context.Context, cluster *MyCluster, query string, ...) (*T, error)

+ func ClusterGetPage(ctx context.Context, cluster *MyCluster, query string, merger *PageMerger[any], ...) ([]*T, error)

+ func ClusterQueryAll(ctx context.Context, cluster *MyCluster, query string, mapper RowMapper, ...) ([][]*T, error)

+ func ClusterQueryOne(ctx context.Context, cluster *MyCluster, query string, mapper RowMapper, ...) (*T, error)

+ func ClusterQueryPage(ctx context.Context, cluster *MyCluster, query string, mapper RowMapper, ...) ([]*T, error)

+ func ConvertToEpochMillis(t time.Time) int64

+ func DecodeRsaPrivateKey(payload []byte) (*rsa.PrivateKey, error)

+ func DecodeRsaPublicKey(payload []byte) (*rsa.PublicKey, error)

+ func GetEpochMillis() int64

+ func GetFieldValueGetters(t reflect.Type) map[string]*FieldValueGetter

+ func GetPartitionKey(id int64) int32

+ func GetTraceID(ctx context.Context) string

+ func LoadRsaPrivateKey(pemFile string) (*rsa.PrivateKey, error)

+ func LoadRsaPublicKey(pemFile string) (*rsa.PublicKey, error)

+ func LogExec(activityID string, start time.Time, err error)

+ func LogOperation(ctx context.Context, operation string, operator func() error) error

+ func LoggingHandler(handler http.Handler) http.Handler

+ func Md5(data []byte) []byte

+ func NewRollingLogWriter(fileName string, maxSizeInMegaBytes, maxRotationFiles int) io.Writer

+ func NewSessionHandler(pipeline http.Handler, store SessionStore, timeout time.Duration, ...) http.Handler

+ func NewSessionID() string

+ func QueryAll(ctx context.Context, queryable Queryable, mapper RowMapper, query string, ...) ([]interface{}, error)

+ func QueryAllEntities(ctx context.Context, queryable Queryable, mapper RowMapper, query string, ...) ([]*TEntity, error)

+ func QueryAllWithCollector(ctx context.Context, queryable Queryable, mapper RowMapper, query string, ...) error

+ func QueryOne(ctx context.Context, queryable Queryable, mapper RowMapper, query string, ...) (interface{}, error)

+ func QueryOneEntity(ctx context.Context, queryable Queryable, mapper RowMapper, query string, ...) (*TEntity, error)

+ func SendError(writer http.ResponseWriter, statusCode int, errorMsg string)

+ func SetupLogger(level LogLevel, writer io.Writer)

+ func Sha1(data []byte) []byte

+ func Sha256(data []byte) []byte

+ func ToSnakeCase(str string) string

+ func TxnGetOne(txn Txn, proto *T) (*T, error)

+ func TxnGetOneByKey(txn Txn, key interface{}) (*T, error)

+ func TxnQueryAll(txn Txn, sql string, mapper RowMapper, args ...interface{}) ([]*T, error)

+ func TxnQueryOne(txn Txn, sql string, mapper RowMapper, args ...interface{}) (*T, error)

+ type Action struct

+ Handler ActionHandler

+ Name string

+ type ActionHandler func(request *http.Request, response *Response)

+ type AuthorizationManager interface

+ CheckAccess func(user *UserPrincipal, method, path string) bool

+ CheckAnonymousAccessible func(method, path string) bool

+ type BufferedWriter struct

+ Buffer [][]byte

+ func NewBufferWriter() *BufferedWriter

+ func (w *BufferedWriter) Write(p []byte) (n int, err error)

+ type ClusterTxn struct

+ ID string

+ LeaseExpiration int64

+ State int

+ Timestamp int64

+ type CollectorCreatorFunc func() DataCollector

+ func (creator CollectorCreatorFunc) Create() DataCollector

+ type CompareFunc func(T, T) int

+ func (f CompareFunc[T]) Compare(lh T, rh T) int

+ type Comparer interface

+ Compare func(lh T, rh T) int

+ type ConcurrentMap struct

+ func NewConcurrentMap() *ConcurrentMap[TKey, TValue]

+ func (m *ConcurrentMap[TKey, TValue]) Delete(key TKey)

+ func (m *ConcurrentMap[TKey, TValue]) Foreach(f func(key TKey, value TValue))

+ func (m *ConcurrentMap[TKey, TValue]) Get(key TKey) (TValue, bool)

+ func (m *ConcurrentMap[TKey, TValue]) GetOrCompute(key TKey, generator func() TValue) TValue

+ func (m *ConcurrentMap[TKey, TValue]) Len() int

+ func (m *ConcurrentMap[TKey, TValue]) Put(key TKey, value TValue) (TValue, bool)

+ func (m *ConcurrentMap[TKey, TValue]) RemoveIf(evaluator func(key TKey, value TValue) bool) int

+ type Controller interface

+ ListActions func() []Action

+ type ControllerFunc func() []Action

+ func AsController(c interface{}) ControllerFunc

+ func (f ControllerFunc) ListActions() []Action

+ type CustomHandler interface

+ PipelineWith func(handler http.Handler) http.Handler

+ type CustomHandlerFunc func(handler http.Handler) http.Handler

+ func (h CustomHandlerFunc) PipelineWith(handler http.Handler) http.Handler

+ type DataCollector interface

+ Collect func(item interface{})

+ type DataCollectorCreator interface

+ Create func() DataCollector

+ type DataCollectorFunc func(item *T)

+ func (collector DataCollectorFunc[T]) Collect(item interface{})

+ type DataRow interface

+ ColumnTypes func() ([]*sql.ColumnType, error)

+ Columns func() ([]string, error)

+ Scan func(dest ...interface{}) error

+ type DbAccessor struct

+ func NewDbAccessor(db *sql.DB) *DbAccessor

+ func (accessor *DbAccessor) BeginTxn(ctx context.Context) (*DbTxn, error)

+ func (accessor *DbAccessor) BeginTxnWithIsolation(ctx context.Context, isolation sql.IsolationLevel) (*DbTxn, error)

+ func (accessor *DbAccessor) Conn(ctx context.Context) (*sql.Conn, error)

+ func (accessor *DbAccessor) Delete(ctx context.Context, entity interface{}) (sql.Result, error)

+ func (accessor *DbAccessor) Execute(ctx context.Context, command string, args ...interface{}) (sql.Result, error)

+ func (accessor *DbAccessor) GetOne(ctx context.Context, proto interface{}) (interface{}, error)

+ func (accessor *DbAccessor) GetOneByKey(ctx context.Context, ty reflect.Type, key interface{}) (interface{}, error)

+ func (accessor *DbAccessor) Insert(ctx context.Context, entity interface{}) (sql.Result, error)

+ func (accessor *DbAccessor) QueryAll(ctx context.Context, query string, mapper RowMapper, args ...interface{}) ([]interface{}, error)

+ func (accessor *DbAccessor) QueryAllWithCollector(ctx context.Context, query string, mapper RowMapper, collector DataCollector, ...) error

+ func (accessor *DbAccessor) QueryOne(ctx context.Context, query string, mapper RowMapper, args ...interface{}) (interface{}, error)

+ func (accessor *DbAccessor) Update(ctx context.Context, entity interface{}) (sql.Result, error)

+ type DbClusterTxnStore struct

+ func NewDbClusterTxnStore(db *DbAccessor) *DbClusterTxnStore

+ func (store *DbClusterTxnStore) AddTxnParticipant(ctx context.Context, txnID string, partition int) error

+ func (store *DbClusterTxnStore) Close() error

+ func (store *DbClusterTxnStore) CreateTxn(ctx context.Context, txnID string, t time.Time) (*ClusterTxn, error)

+ func (store *DbClusterTxnStore) DeleteTxn(ctx context.Context, txnID string) error

+ func (store *DbClusterTxnStore) GetTxn(ctx context.Context, txnID string) (*ClusterTxn, error)

+ func (store *DbClusterTxnStore) LeaseExpiredTxns(ctx context.Context, expireTime, leaseTimeout time.Time, items int) ([]*ClusterTxn, error)

+ func (store *DbClusterTxnStore) ListParticipants(ctx context.Context, txnID string) ([]*TxnParticipant, error)

+ func (store *DbClusterTxnStore) UpdateTxnState(ctx context.Context, txnID string, state int) error

+ type DbTxn struct

+ func (txn *DbTxn) Close()

+ func (txn *DbTxn) Commit() error

+ func (txn *DbTxn) Delete(entity interface{}) (sql.Result, error)

+ func (txn *DbTxn) Execute(command string, args ...interface{}) (sql.Result, error)

+ func (txn *DbTxn) GetOne(proto interface{}) (interface{}, error)

+ func (txn *DbTxn) GetOneByKey(ty reflect.Type, key interface{}) (interface{}, error)

+ func (txn *DbTxn) Insert(entity interface{}) (sql.Result, error)

+ func (txn *DbTxn) QueryAll(query string, mapper RowMapper, args ...interface{}) ([]interface{}, error)

+ func (txn *DbTxn) QueryAllWithCollector(query string, mapper RowMapper, collector DataCollector, args ...interface{}) error

+ func (txn *DbTxn) QueryOne(query string, mapper RowMapper, args ...interface{}) (interface{}, error)

+ func (txn *DbTxn) Rollback() error

+ func (txn *DbTxn) Update(entity interface{}) (sql.Result, error)

+ type DbUniqueIDGenerator struct

+ func NewDbUniqueIDGenerator(dbAccessor *DbAccessor) *DbUniqueIDGenerator

+ func (generator *DbUniqueIDGenerator) NextUniqueID(ctx context.Context, name string, partition int32) (UniqueID, error)

+ type DistributedLocker interface

+ Lock func(ctx context.Context) (LockContext, error)

+ Unlock func(lockCtx LockContext)

+ type DistributedSharedLocker interface

+ Lock func(ctx context.Context) (LockContext, error)

+ RLock func(ctx context.Context) (LockContext, error)

+ RUnlock func(lockCtx LockContext)

+ Unlock func(lockCtx LockContext)

+ type DummyWriter struct

+ func (w *DummyWriter) Write(p []byte) (n int, err error)

+ type EntityDescriptor struct

+ DeleteSQL string

+ GetOneSQL string

+ InsertSQL string

+ UpdateSQL string

+ func GetOrCreateEntityDescriptor(entityType reflect.Type) *EntityDescriptor

+ func (descriptor *EntityDescriptor) GetInsertValues(entity interface{}) []interface{}

+ func (descriptor *EntityDescriptor) GetKeyValues(entity interface{}) []interface{}

+ func (descriptor *EntityDescriptor) GetUpdateValues(entity interface{}) []interface{}

+ type FieldValueGetter struct

+ func NewFieldValueGetter(fieldName string) *FieldValueGetter

+ func (getter *FieldValueGetter) Get(value reflect.Value) reflect.Value

+ type JwtKeyMap map[string]*rsa.PublicKey

+ func (m JwtKeyMap) GetBackupKey(_ context.Context, issuer string) *rsa.PublicKey

+ func (m JwtKeyMap) GetKey(_ context.Context, issuer string) *rsa.PublicKey

+ type JwtKeyProvider interface

+ GetBackupKey func(ctx context.Context, issuer string) *rsa.PublicKey

+ GetKey func(ctx context.Context, issuer string) *rsa.PublicKey

+ type JwtUserClaims struct

+ AccountName string

+ Domain string

+ Name string

+ Parent string

+ Roles []string

+ SecurityToken string

+ Sid string

+ type JwtUserPrincipal struct

+ DisplayName string

+ Parent string

+ SecurityToken string

+ Source string

+ type JwtUserProvider struct

+ func NewJwtUserProvider(keyProvider JwtKeyProvider, userLoader UserPrincipalLoader) *JwtUserProvider

+ func (provider *JwtUserProvider) Authenticate(request *http.Request) *UserPrincipal

+ func (provider *JwtUserProvider) GetName() string

+ func (provider *JwtUserProvider) Load(domain, id string) *UserPrincipal

+ type KeepAliveMessageHandler interface

+ OnPingMessage func(session *WebSocketSession, text string) error

+ OnPongMessage func(session *WebSocketSession, text string) error

+ type LockContext map[string]interface

+ type LogLevel int32

+ const LogLevelDebug

+ const LogLevelError

+ const LogLevelInfo

+ const LogLevelWarn

+ type MyCluster struct

+ func NewMyCluster(master *DbAccessor, partitions []*DbAccessor, txnTimeout int, ...) *MyCluster

+ func NewMyClusterWithTxnStore(txnStore TxnStore, partitions []*DbAccessor, txnTimeout int, ...) *MyCluster

+ func (cluster *MyCluster) Close()

+ func (cluster *MyCluster) CreateTransaction(ctx context.Context) (*MyClusterTxn, error)

+ func (cluster *MyCluster) Delete(ctx context.Context, entity interface{}) (sql.Result, error)

+ func (cluster *MyCluster) ExecuteOnAll(ctx context.Context, query string, args ...interface{}) error

+ func (cluster *MyCluster) GenerateKey(ctx context.Context, entity interface{}) error

+ func (cluster *MyCluster) GetAll(ctx context.Context, ty reflect.Type, query string, args ...interface{}) ([][]interface{}, error)

+ func (cluster *MyCluster) GetAllPartitions() []*DbAccessor

+ func (cluster *MyCluster) GetAllReduced(ctx context.Context, ty reflect.Type, query string, ...) ([]interface{}, error)

+ func (cluster *MyCluster) GetAllWithCollector(ctx context.Context, ty reflect.Type, query string, ...) error

+ func (cluster *MyCluster) GetAnyPartition() *DbAccessor

+ func (cluster *MyCluster) GetDbAccessor(partition int32) *DbAccessor

+ func (cluster *MyCluster) GetDbAccessorByID(id int64) *DbAccessor

+ func (cluster *MyCluster) GetDbAccessorByKey(partitionKey string) *DbAccessor

+ func (cluster *MyCluster) GetOne(ctx context.Context, ty reflect.Type, query string, ...) (interface{}, error)

+ func (cluster *MyCluster) GetPage(ctx context.Context, ty reflect.Type, query string, merger *PageMerger[any], ...) ([]interface{}, error)

+ func (cluster *MyCluster) GetPartitionByKey(key string) int32

+ func (cluster *MyCluster) GetUniqueID(ctx context.Context, entity interface{}, partition int32) (int64, error)

+ func (cluster *MyCluster) GetUniqueIDByName(ctx context.Context, entityName string, partition int32) (int64, error)

+ func (cluster *MyCluster) Insert(ctx context.Context, entity interface{}) error

+ func (cluster *MyCluster) InsertAt(ctx context.Context, partition int32, entity interface{}) error

+ func (cluster *MyCluster) InsertByKey(ctx context.Context, partitionKey string, entity interface{}) error

+ func (cluster *MyCluster) InsertToAll(ctx context.Context, entity interface{}) error

+ func (cluster *MyCluster) QueryAll(ctx context.Context, query string, mapper RowMapper, args ...interface{}) ([][]interface{}, error)

+ func (cluster *MyCluster) QueryAllReduced(ctx context.Context, query string, mapper RowMapper, ...) ([]interface{}, error)

+ func (cluster *MyCluster) QueryAllWithCollector(ctx context.Context, query string, mapper RowMapper, ...) error

+ func (cluster *MyCluster) QueryOne(ctx context.Context, query string, mapper RowMapper, ...) (interface{}, error)

+ func (cluster *MyCluster) QueryPage(ctx context.Context, query string, mapper RowMapper, merger *PageMerger[any], ...) ([]interface{}, error)

+ func (cluster *MyCluster) Update(ctx context.Context, entity interface{}) error

+ func (cluster *MyCluster) UpdateAt(ctx context.Context, partition int32, entity interface{}) error

+ func (cluster *MyCluster) UpdateToAll(ctx context.Context, entity interface{}) error

+ type MyClusterTxn struct

+ func (txn *MyClusterTxn) Close()

+ func (txn *MyClusterTxn) Commit() error

+ func (txn *MyClusterTxn) Delete(entity interface{}) (sql.Result, error)

+ func (txn *MyClusterTxn) DeleteAt(partition int32, entity interface{}) (sql.Result, error)

+ func (txn *MyClusterTxn) DeleteFromAll(entity interface{}) ([]sql.Result, error)

+ func (txn *MyClusterTxn) ExecuteAt(partition int32, sql string, args ...interface{}) (sql.Result, error)

+ func (txn *MyClusterTxn) ExecuteOnAll(query string, args ...interface{}) ([]sql.Result, error)

+ func (txn *MyClusterTxn) GetTxnByID(id int64) (*XATransaction, error)

+ func (txn *MyClusterTxn) GetTxnByPartition(partition int32) (*XATransaction, error)

+ func (txn *MyClusterTxn) InsertAt(partition int32, entity interface{}) (sql.Result, error)

+ func (txn *MyClusterTxn) InsertToAll(entity interface{}) ([]sql.Result, error)

+ func (txn *MyClusterTxn) Rollback() error

+ func (txn *MyClusterTxn) Update(entity interface{}) (sql.Result, error)

+ func (txn *MyClusterTxn) UpdateAt(partition int32, entity interface{}) (sql.Result, error)

+ func (txn *MyClusterTxn) UpdateToAll(entity interface{}) ([]sql.Result, error)

+ type PageMerger struct

+ func NewPageMerger(pageSize int, comparer Comparer[T]) *PageMerger[T]

+ func (m *PageMerger[T]) Merge(lists ...[]T) []T

+ type PartitionCalculateFunc func(key string) int32

+ func (calc PartitionCalculateFunc) GetPartition(key string) int32

+ type PartitionCalculator interface

+ GetPartition func(key string) int32

+ type PooledID struct

+ Name string

+ Partition int32

+ PooledID int64

+ type Queryable interface

+ QueryContext func(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)

+ QueryRowContext func(ctx context.Context, query string, args ...interface{}) *sql.Row

+ type Response struct

+ Writer http.ResponseWriter

+ func (r *Response) DoneWithContent(statusCode int, contentType string, content []byte)

+ func (r *Response) DoneWithError(statusCode int, msg string)

+ func (r *Response) DoneWithJSON(statusCode int, obj interface{})

+ func (r *Response) DoneWithRedirect(req *http.Request, url string, status int)

+ func (r *Response) DoneWithTemplate(statusCode int, name string, model interface{})

+ func (r *Response) SetCookie(cookie *http.Cookie)

+ func (r *Response) SetHeader(name, value string)

+ func (r *Response) SetNoCache()

+ func (r *Response) SetStatus(statusCode int)

+ func (r *Response) Write(content []byte) (int, error)

+ type RowMapper interface

+ Map func(row DataRow) (interface{}, error)

+ func NewSmartMapper(ty reflect.Type) RowMapper

+ type RowMapperFunc func(row DataRow) (interface{}, error)

+ func (mapper RowMapperFunc) Map(row DataRow) (interface{}, error)

+ type SecurityHandler struct

+ func NewSecurityHandler() *SecurityHandler

+ func (handler *SecurityHandler) AddUserProvider(userProvider UserProvider) *SecurityHandler

+ func (handler *SecurityHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request)

+ func (handler *SecurityHandler) WithAuthz(authz AuthorizationManager) *SecurityHandler

+ func (handler *SecurityHandler) WithLoginURL(loginURL string) *SecurityHandler

+ func (handler *SecurityHandler) WithPipeline(h http.Handler) *SecurityHandler

+ type Session struct

+ ID string

+ IsValid bool

+ func GetSession(request *http.Request) *Session

+ func NewSession(id string) *Session

+ func (session *Session) Deserialize(data []byte)

+ func (session *Session) GetAsFlashValue(key string) (interface{}, bool)

+ func (session *Session) GetValue(key string) (interface{}, bool)

+ func (session *Session) NeedSave() bool

+ func (session *Session) Serialize() []byte

+ func (session *Session) SetValue(key string, value interface{}) (interface{}, bool)

+ type SessionStore interface

+ Close func()

+ Get func(id string) (*Session, error)

+ Save func(session *Session, timeout time.Duration) error

+ func NewFileSessionStore(directory string) (SessionStore, error)

+ func NewInMemorySessionStore() SessionStore

+ func NewRedisSessionStore(cli *redis.Client) SessionStore

+ type SharedTemplateDetector func(string) bool

+ type SkinManager struct

+ func NewSkinManager(defaultSkin *TemplateManager) *SkinManager

+ func (skinMgr *SkinManager) AddSkin(name string, tmplMgr *TemplateManager)

+ func (skinMgr *SkinManager) ApplySelector(request *http.Request) (*TemplateManager, string)

+ func (skinMgr *SkinManager) GetDefaultSkin() *TemplateManager

+ func (skinMgr *SkinManager) GetSkin(name string) (*TemplateManager, bool)

+ func (skinMgr *SkinManager) GetSkinOrDefault(name string) *TemplateManager

+ func (skinMgr *SkinManager) RemoveSkin(name string)

+ func (skinMgr *SkinManager) WithSelector(selector SkinSelector)

+ type SkinSelector interface

+ GetSkin func(request *http.Request) string

+ type SkinSelectorFunc func(*http.Request) string

+ type SliceCollector struct

+ Results []*T

+ func NewSliceCollector() *SliceCollector[T]

+ func (collector *SliceCollector[T]) Collect(item interface{})

+ type SliceCollectorCreator struct

+ Collectors []*SliceCollector[T]

+ func NewSliceCollectorCreator() *SliceCollectorCreator[T]

+ func (creator *SliceCollectorCreator[T]) Create() DataCollector

+ func (creator *SliceCollectorCreator[T]) GetResults() [][]*T

+ func (creator *SliceCollectorCreator[T]) MergeResults(merger *PageMerger[*T]) []*T

+ type TableNameResolver interface

+ Resolve func(structName string) string

+ type TableNameResolverFunc func(structName string) string

+ func (resolver TableNameResolverFunc) Resolve(name string) string

+ type TemplateConfigFunc func(*template.Template)

+ type TemplateManager struct

+ func NewTemplateManager(dir, suffix string, refreshInterval time.Duration, ...) *TemplateManager

+ func (manager *TemplateManager) Close()

+ func (manager *TemplateManager) GetTemplate(name string) (*template.Template, bool)

+ type Txn interface

+ Delete func(entity interface{}) (sql.Result, error)

+ Execute func(sql string, args ...interface{}) (sql.Result, error)

+ GetOne func(proto interface{}) (interface{}, error)

+ GetOneByKey func(ty reflect.Type, key interface{}) (interface{}, error)

+ Insert func(entity interface{}) (sql.Result, error)

+ QueryAll func(sql string, mapper RowMapper, args ...interface{}) ([]interface{}, error)

+ QueryAllWithCollector func(sql string, mapper RowMapper, collector DataCollector, args ...interface{}) error

+ QueryOne func(sql string, mapper RowMapper, args ...interface{}) (interface{}, error)

+ Update func(entity interface{}) (sql.Result, error)

+ type TxnParticipant struct

+ Partition int

+ State int

+ TxnID string

+ type TxnStore interface

+ AddTxnParticipant func(ctx context.Context, txnID string, partition int) error

+ Close func() error

+ CreateTxn func(ctx context.Context, txnID string, t time.Time) (*ClusterTxn, error)

+ DeleteTxn func(ctx context.Context, txnID string) error

+ GetTxn func(ctx context.Context, txnID string) (*ClusterTxn, error)

+ LeaseExpiredTxns func(ctx context.Context, expireTime, leaseTimeout time.Time, items int) ([]*ClusterTxn, error)

+ ListParticipants func(ctx context.Context, txnID string) ([]*TxnParticipant, error)

+ UpdateTxnState func(ctx context.Context, txnID string, state int) error

+ type UniqueID struct

+ Value int64

+ func NewUniqueID(pooledID int64, partition int32, segmentedID int32) (UniqueID, error)

+ func (id UniqueID) Partition() int32

+ type UniqueIDGenerator interface

+ NextUniqueID func(ctx context.Context, name string, partition int32) (UniqueID, error)

+ type UniqueIDPool struct

+ Lock *sync.Mutex

+ func NewUniqueIDPool() *UniqueIDPool

+ func (pool *UniqueIDPool) NextID(ctx context.Context, partition int32) (int64, error)

+ func (pool *UniqueIDPool) UpdatePooledID(partition int32, pooledID int64) error

+ type UserPrincipal struct

+ Domain string

+ ID string

+ Name string

+ Provider string

+ Roles []string

+ Self interface{}

+ func GetUser(request *http.Request) *UserPrincipal

+ type UserPrincipalLoader interface

+ Load func(domain, id string) *UserPrincipal

+ type UserPrincipalLoaderFunc func(domain, id string) *UserPrincipal

+ func (f UserPrincipalLoaderFunc) Load(domain, id string) *UserPrincipal

+ type UserProvider interface

+ Authenticate func(request *http.Request) *UserPrincipal

+ GetName func() string

+ Load func(domain, id string) *UserPrincipal

+ type WebServer struct

+ func NewWebServer(listenAddr string, skinMgr *SkinManager) *WebServer

+ func (server *WebServer) AddStaticResource(prefix, dir string) *WebServer

+ func (server *WebServer) AddUserProvider(provider UserProvider) *WebServer

+ func (server *WebServer) AddWsEndoint(endpoint string, listener WebSocketListener) *WebServer

+ func (server *WebServer) AddWsHandler(endpoint string, handler *WebSocketHandler) *WebServer

+ func (server *WebServer) HandleFunc(path string, f func(w http.ResponseWriter, r *http.Request)) *WebServer

+ func (server *WebServer) RegisterController(name string, controller Controller) error

+ func (server *WebServer) Shutdown()

+ func (server *WebServer) Start() error

+ func (server *WebServer) WithAuthz(authz AuthorizationManager) *WebServer

+ func (server *WebServer) WithCORS(handler func(http.Handler) http.Handler) *WebServer

+ func (server *WebServer) WithCaptcha(path string) *WebServer

+ func (server *WebServer) WithCaptchaCustom(path string, digits, width, height int) *WebServer

+ func (server *WebServer) WithCustomHandler(handler CustomHandler) *WebServer

+ func (server *WebServer) WithLoginURL(loginURL string) *WebServer

+ func (server *WebServer) WithRequestTimeout(timeout int)

+ func (server *WebServer) WithSessionOptions(store SessionStore, timeout time.Duration, valueTypes ...interface{}) *WebServer

+ func (server *WebServer) WithStandardRouting(prefix string) *WebServer

+ type WebSocketHandler struct

+ CheckOrigin func(*http.Request) bool

+ Listener WebSocketListener

+ MessageLimit int64

+ ReadTimeout time.Duration

+ WriteCompression bool

+ WriteTimeout time.Duration

+ func (handler *WebSocketHandler) Handle(writer http.ResponseWriter, request *http.Request)

+ type WebSocketListener interface

+ OnBinaryMessage func(session *WebSocketSession, data []byte)

+ OnClose func(session *WebSocketSession, reason int)

+ OnConnect func(session *WebSocketSession)

+ OnTextMessage func(session *WebSocketSession, text string)

+ type WebSocketSession struct

+ Context map[string]interface{}

+ RemoteAddr string

+ Session *Session

+ User *UserPrincipal

+ func (session *WebSocketSession) Close() error

+ func (session *WebSocketSession) SendBinaryMessage(data []byte) error

+ func (session *WebSocketSession) SendMessage(msgType int, data []byte) error

+ func (session *WebSocketSession) SendTextMessage(text string) error

+ type XATransaction struct

+ func (xa *XATransaction) Begin() error

+ func (xa *XATransaction) Close()

+ func (xa *XATransaction) Delete(entity interface{}) (sql.Result, error)

+ func (xa *XATransaction) Execute(command string, args ...interface{}) (sql.Result, error)

+ func (xa *XATransaction) GetOne(proto interface{}) (interface{}, error)

+ func (xa *XATransaction) GetOneByKey(ty reflect.Type, key interface{}) (interface{}, error)

+ func (xa *XATransaction) Insert(entity interface{}) (sql.Result, error)

+ func (xa *XATransaction) QueryAll(query string, mapper RowMapper, args ...interface{}) ([]interface{}, error)

+ func (xa *XATransaction) QueryAllWithCollector(query string, mapper RowMapper, collector DataCollector, args ...interface{}) error

+ func (xa *XATransaction) QueryOne(query string, mapper RowMapper, args ...interface{}) (interface{}, error)

+ func (xa *XATransaction) Update(entity interface{}) (sql.Result, error)

+ type XaTxnID struct

+ BranchIDLength int

+ Data string

+ FormatID int

+ GlobalIDLength int

+ type ZkLock struct

+ func NewZkLock(conn *zk.Conn, path string) *ZkLock

+ func (lock *ZkLock) Lock(ctx context.Context) (LockContext, error)

+ func (lock *ZkLock) Release()

+ func (lock *ZkLock) Unlock(lockCtx LockContext)

+ type ZkLock2 struct

+ func NewZkLock2(conn *zk.Conn, path string) (*ZkLock2, error)

+ func (lock *ZkLock2) Lock(ctx context.Context) (LockContext, error)

+ func (lock *ZkLock2) Unlock(lockCtx LockContext)

+ type ZkRWLock struct

+ func NewZkRWLock(conn *zk.Conn, path string) (*ZkRWLock, error)

+ func (rwLock *ZkRWLock) Lock(ctx context.Context) (LockContext, error)

+ func (rwLock *ZkRWLock) RLock(ctx context.Context) (LockContext, error)

+ func (rwLock *ZkRWLock) RUnlock(lockCtx LockContext)

+ func (rwLock *ZkRWLock) Unlock(lockCtx LockContext)

+ type ZkRWLock2 struct

+ func NewZkRWLock2(conn *zk.Conn, path string) (*ZkRWLock2, error)

+ func (lock *ZkRWLock2) Lock(ctx context.Context) (LockContext, error)

+ func (lock *ZkRWLock2) RLock(ctx context.Context) (LockContext, error)

+ func (lock *ZkRWLock2) RUnlock(lockCtx LockContext)

+ func (lock *ZkRWLock2) Unlock(lockCtx LockContext)

v1.4.7

May 17, 2022

v1.4.6

May 17, 2022

v1.4.5

Apr 16, 2022

v1.4.4

Apr 15, 2022

v1.4.3

Apr 10, 2022

v1.4.2

Mar 18, 2022

v1.4.1

Mar 17, 2022

v1.4.0

Mar 16, 2022

v1.3.6

Jan 21, 2022

v1.3.5

May 10, 2021

v1.3.4

May 8, 2021

v1.3.3

May 7, 2021

v1.3.2

Apr 28, 2021

v1.3.1

Apr 17, 2021

v1.3.0

Apr 16, 2021

v1.2.4

Mar 16, 2021

v1.2.3

Mar 4, 2021

v1.2.2

Feb 24, 2021

v1.2.1

Feb 10, 2021

v1.2.0

Feb 8, 2021

v1.1.10

Mar 31, 2020

v1.1.9

Mar 27, 2020

v0

v0.9.6

Aug 7, 2019

v0.9.5

Aug 7, 2019

v0.9.4

Aug 7, 2019

v0.9.3

Jul 15, 2019

v0.9.2

Jul 11, 2019

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL