go_rbac

README

go-rbac

dccn-rbac-{app, web} project client package

Documentation

Overview

Copyright 2019 The Ankr crop. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

Package go_rbac provides RBAC client implementations.

create new client:

	c, err := New("127.0.0.1:6801")
    ...

authorize something:

   rsp, err := c.Authorize(ctx, &Request{
		Subject:  "ankr",
		Resource: "/v1/path/to/rc",
		Action:   "read",
	})
   ...

Index

• type Client
  • func New(srvAddr string) (Client, error)
• type ConfigMgr
  • func NewDefaultConfigMgr() *ConfigMgr
• type Manager
  • func NewManager() Manager
• type Policy
• type QueryReq
• type Request
• type Resource
• type ResourceAddRequest
• type ResourceAddResponse
• type ResourceDelRequest
• type ResourceDelResponse
• type ResourceMgr
  • func NewResourceMgr(cfg ConfigMgr) ResourceMgr
• type ResourceModRequest
• type ResourceModResponse
• type ResourceQryRequest
• type ResourceQryResponse
• type Resp
• type Response
• type Role
• type RoleAddRequest
• type RoleAddResponse
• type RoleBindResourceMgr
  • func NewRoleBindResourceMgr(cfg ConfigMgr) RoleBindResourceMgr
• type RoleBindingResource
• type RoleBindingResourceAddRequest
• type RoleBindingResourceAddResponse
• type RoleBindingResourceDelRequest
• type RoleBindingResourceDelResponse
• type RoleBindingResourceListRequest
• type RoleBindingResourceListResponse
• type RoleBindingResourceModRequest
• type RoleBindingResourceModResponse
• type RoleBindingResourceQryRequest
• type RoleBindingResourceQryResponse
• type RoleDelRequest
• type RoleDelResponse
• type RoleMgr
  • func NewRoleMgr(cfg *ConfigMgr) RoleMgr
• type RoleModRequest
• type RoleModResponse
• type RoleQryRequest
• type RoleQryResponse
• type User
• type UserAddRequest
• type UserAddResponse
• type UserDelRequest
• type UserDelResponse
• type UserListRequest
• type UserListResponse
• type UserMgr
  • func NewUserMgr(cfg *ConfigMgr) (UserMgr, error)
• type UserModRequest
• type UserModResponse
• type UserQryRequest
• type UserQryResponse

Types

type Client

type Client interface {
	Close() error
	Authorize(ctx context.Context, req *Request) (*Response, error)
}

func New

func New(srvAddr string) (Client, error)

New create new client for remote rbac server

type ConfigMgr

type ConfigMgr struct {
	Addr string
}

func NewDefaultConfigMgr

func NewDefaultConfigMgr() *ConfigMgr

type Manager

type Manager interface {
	AddRole(ctx context.Context, roleName string) error
	UserBindRole(ctx context.Context, user, role string) error
	AddPolicy(ctx context.Context, catalog, subject, resource, action, policy string) error
}

func NewManager

func NewManager() Manager

type Policy

type Policy struct {
	Id       int64
	Type     string
	Subject  string
	Resource string
	Action   string
	Permit   string
	Status   int64
}

type QueryReq

type QueryReq struct {
	Page int64
	Size int64
	Type string
}

type Request

type Request struct {
	// the executor which execute the spec action
	Subject string
	// the resource such as  the name of data
	// or the name of url(/v1/path/to/role) and so on.
	Resource string
	// the action such as Read, Write, PUT, POST and so on,
	// it which exists in reality is valid and reasonable.
	Action string
}

type Resource

type Resource struct {
	Id     int64
	Type   string
	Name   string
	Value  string
	Source string
	Memo   string
	Status int64
}

type ResourceAddRequest

type ResourceAddRequest struct {
	Type   string
	Name   string
	Value  string
	Source string
	Memo   string
}

type ResourceAddResponse

type ResourceAddResponse struct {
	Resp
}

type ResourceDelRequest

type ResourceDelRequest struct {
	ID int64
}

type ResourceDelResponse

type ResourceDelResponse struct {
	Resp
}

type ResourceMgr

type ResourceMgr interface {
	Add(ctx context.Context, req *ResourceAddRequest) (*ResourceAddResponse, error)
	Del(ctx context.Context, req *ResourceDelRequest) (*ResourceDelResponse, error)
	Mod(ctx context.Context, req *ResourceModRequest) (*ResourceModResponse, error)
	Qry(ctx context.Context, req *ResourceQryRequest) (*ResourceQryResponse, error)
}

func NewResourceMgr

func NewResourceMgr(cfg ConfigMgr) ResourceMgr

NewResourceMgr feature 1. weather to choose keep-live feature, I think about it for long time, at last I decide to take it, because as usual, our network is the internal and stable, if appear error when use role manager, please recreate it 2. if the network is not stable, the action of create role manager will go on until create it successfully.

type ResourceModRequest

type ResourceModRequest struct {
	Resource
}

type ResourceModResponse

type ResourceModResponse struct {
	Resp
}

type ResourceQryRequest

type ResourceQryRequest struct {
	QueryReq
}

type ResourceQryResponse

type ResourceQryResponse struct {
	Resp
	Total int64
	Data  []*Resource
}

type Resp

type Resp struct {
	Code int64
	Desc string
}

type Response

type Response struct {
	// true means passed.
	// false means failed.
	OK bool
}

judge result response

type Role

type Role struct {
	Id     int64
	Name   string
	Type   string
	Memo   string
	Status int64
}

type RoleAddRequest

type RoleAddRequest struct {
	Type string
	Name string
	Memo string
}

type RoleAddResponse

type RoleAddResponse struct {
	Resp
}

type RoleBindResourceMgr

type RoleBindResourceMgr interface {
	Add(ctx context.Context, req *RoleBindingResourceAddRequest) (*RoleBindingResourceAddResponse, error)
	Del(ctx context.Context, req *RoleBindingResourceDelRequest) (*RoleBindingResourceDelResponse, error)
	Mod(ctx context.Context, req *RoleBindingResourceModRequest) (*RoleBindingResourceModResponse, error)
	Qry(ctx context.Context, req *RoleBindingResourceQryRequest) (*RoleBindingResourceQryResponse, error)
	List(ctx context.Context, req *RoleBindingResourceListRequest) (*RoleBindingResourceListResponse, error)
}

func NewRoleBindResourceMgr

func NewRoleBindResourceMgr(cfg ConfigMgr) RoleBindResourceMgr

type RoleBindingResource

type RoleBindingResource struct {
	Id       int64
	Type     string
	Subject  string
	Resource string
	Action   string
	Policy   string
	Status   int64
}

type RoleBindingResourceAddRequest

type RoleBindingResourceAddRequest struct {
	Type     string
	Subject  string
	Resource string
	Action   string
	Policy   string
}

type RoleBindingResourceAddResponse

type RoleBindingResourceAddResponse struct {
	Resp
}

type RoleBindingResourceDelRequest

type RoleBindingResourceDelRequest struct {
	Id int64
}

type RoleBindingResourceDelResponse

type RoleBindingResourceDelResponse struct {
	Resp
}

type RoleBindingResourceListRequest

type RoleBindingResourceListRequest struct {
	Type string
}

type RoleBindingResourceListResponse

type RoleBindingResourceListResponse struct {
	Resp
	Data []*RoleBindingResource
}

type RoleBindingResourceModRequest

type RoleBindingResourceModRequest struct {
	Policy
}

type RoleBindingResourceModResponse

type RoleBindingResourceModResponse struct {
	Resp
}

type RoleBindingResourceQryRequest

type RoleBindingResourceQryRequest struct {
	QueryReq
}

type RoleBindingResourceQryResponse

type RoleBindingResourceQryResponse struct {
	Resp
	Total int64
	Data  []*Policy
}

type RoleDelRequest

type RoleDelRequest struct {
	ID int64
}

type RoleDelResponse

type RoleDelResponse struct {
	Resp
}

type RoleMgr

type RoleMgr interface {
	Add(ctx context.Context, req *RoleAddRequest) (*RoleAddResponse, error)
	Del(ctx context.Context, req *RoleDelRequest) (*RoleDelResponse, error)
	Mod(ctx context.Context, req *RoleModRequest) (*RoleModResponse, error)
	Qry(ctx context.Context, req *RoleQryRequest) (*RoleQryResponse, error)
}

func NewRoleMgr

func NewRoleMgr(cfg *ConfigMgr) RoleMgr

NewRoleMgr create role manager handler feature 1. weather to choose keep-live feature, I think about it for long time, at last I decide to start it, because as usual, our network is the internal and stable, if appear error when use role manager, please recreate it 2. if the network is not stable, the action of create role manager will go on until create it successfully.

type RoleModRequest

type RoleModRequest struct {
	Role
}

type RoleModResponse

type RoleModResponse struct {
	Resp
}

type RoleQryRequest

type RoleQryRequest struct {
	QueryReq
}

type RoleQryResponse

type RoleQryResponse struct {
	Resp
	Total int64
	Data  []*Role
}

type User

type User struct {
	Id     int64
	Type   string
	User   string
	Role   string
	Status int64
}

type UserAddRequest

type UserAddRequest struct {
	Type string
	User string
	Role string
}

type UserAddResponse

type UserAddResponse struct {
	Resp
}

type UserDelRequest

type UserDelRequest struct {
	Id int64
}

type UserDelResponse

type UserDelResponse struct {
	Resp
}

type UserListRequest

type UserListRequest struct {
	Type string
}

type UserListResponse

type UserListResponse struct {
	Resp
	Data []*User
}

type UserMgr

type UserMgr interface {
	Add(context.Context, *UserAddRequest) (*UserAddResponse, error)
	Del(context.Context, *UserDelRequest) (*UserDelResponse, error)
	Mod(context.Context, *UserModRequest) (*UserModResponse, error)
	Qry(context.Context, *UserQryRequest) (*UserQryResponse, error)
	List(context.Context, *UserListRequest) (*UserListResponse, error)
}

func NewUserMgr

func NewUserMgr(cfg *ConfigMgr) (UserMgr, error)

type UserModRequest

type UserModRequest struct {
	User *User
}

type UserModResponse

type UserModResponse struct {
	Resp
}

type UserQryRequest

type UserQryRequest struct {
	Page int64
	Num  int64
	Type string
}

type UserQryResponse

type UserQryResponse struct {
	Resp
	Data  []*User
	Total int64
}