user.go

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package main

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"time"
)

import (
	hessian "github.com/apache/dubbo-go-hessian2"
	"github.com/apache/dubbo-go/config"
)

func init() {
	config.SetProviderService(new(UserProvider))
	// ------for hessian2------
	hessian.RegisterPOJO(&User{})

	cache = &UserDB{
		cacheMap:  make(map[string]*User, 16),
		cacheMapC: make(map[int64]*User, 16),
		lock:      sync.Mutex{},
	}

	cache.Add(&User{ID: "0001", Code: 1, Name: "tc", Age: 18, Time: time.Now()})
	cache.Add(&User{ID: "0002", Code: 2, Name: "ic", Age: 88, Time: time.Now()})
}

var cache *UserDB

// UserDB cache user.
type UserDB struct {
	// key is name, value is user obj
	cacheMap  map[string]*User
	cacheMapC map[int64]*User
	lock      sync.Mutex
}

// Add add user
func (db *UserDB) Add(u *User) bool {
	res := db.AddForName(u)
	if !res {
		return false
	}

	return db.AddForCode(u)
}

// AddForName add user with name
func (db *UserDB) AddForName(u *User) bool {
	db.lock.Lock()
	defer db.lock.Unlock()

	if len(u.Name) == 0 {
		return false
	}

	if _, ok := db.cacheMap[u.Name]; ok {
		return false
	}

	db.cacheMap[u.Name] = u
	return true
}

// AddForCode add user with code
func (db *UserDB) AddForCode(u *User) bool {
	db.lock.Lock()
	defer db.lock.Unlock()

	if u.Code == 0 {
		return false
	}

	if _, ok := db.cacheMapC[u.Code]; ok {
		return false
	}

	db.cacheMapC[u.Code] = u
	return true
}

// GetByName find user by name
func (db *UserDB) GetByName(n string) (*User, bool) {
	db.lock.Lock()
	defer db.lock.Unlock()

	r, ok := db.cacheMap[n]
	return r, ok
}

// GetByCode find user by code
func (db *UserDB) GetByCode(n int64) (*User, bool) {
	db.lock.Lock()
	defer db.lock.Unlock()

	r, ok := db.cacheMapC[n]
	return r, ok
}

// User user obj.
type User struct {
	ID   string    `json:"id,omitempty"`
	Code int64     `json:"code,omitempty"`
	Name string    `json:"name,omitempty"`
	Age  int32     `json:"age,omitempty"`
	Time time.Time `json:"time,omitempty"`
}

// UserProvider the dubbo provider.
// like: version: 1.0.0 group: test
type UserProvider struct {
}

// CreateUser new user, PX config POST.
func (u *UserProvider) CreateUser(ctx context.Context, user *User) (*User, error) {
	println("Req CreateUser data:%#v", user)
	if user == nil {
		return nil, errors.New("not found")
	}
	_, ok := cache.GetByName(user.Name)
	if ok {
		return nil, errors.New("data is exist")
	}

	b := cache.Add(user)
	if b {
		return user, nil
	}

	return nil, errors.New("add error")
}

// GetUserByName query by name, single param, PX config GET.
func (u *UserProvider) GetUserByName(ctx context.Context, name string) (*User, error) {
	println("Req GetUserByName name:%#v", name)
	r, ok := cache.GetByName(name)
	if ok {
		println("Req GetUserByName result:%#v", r)
		return r, nil
	}
	return nil, nil
}

// GetUserByCode query by code, single param, PX config GET.
func (u *UserProvider) GetUserByCode(ctx context.Context, code int64) (*User, error) {
	println("Req GetUserByCode name:%#v", code)
	r, ok := cache.GetByCode(code)
	if ok {
		println("Req GetUserByCode result:%#v", r)
		return r, nil
	}
	return nil, nil
}

// GetUserTimeout query by name, will timeout for pixiu.
func (u *UserProvider) GetUserTimeout(ctx context.Context, name string) (*User, error) {
	println("Req GetUserTimeout name:%#v", name)
	// sleep 10s, pixiu config less than 10s.
	time.Sleep(10 * time.Second)
	r, ok := cache.GetByName(name)
	if ok {
		println("Req GetUserTimeout result:%#v", r)
		return r, nil
	}
	return nil, nil
}

// GetUserByNameAndAge query by name and age, two params, PX config GET.
func (u *UserProvider) GetUserByNameAndAge(ctx context.Context, name string, age int32) (*User, error) {
	println("Req GetUserByNameAndAge name:%s, age:%d", name, age)
	r, ok := cache.GetByName(name)
	if ok && r.Age == age {
		println("Req GetUserByNameAndAge result:%#v", r)
		return r, nil
	}
	return r, nil
}

// UpdateUser update by user struct, my be another struct, PX config POST or PUT.
func (u *UserProvider) UpdateUser(ctx context.Context, user *User) (bool, error) {
	println("Req UpdateUser data:%#v", user)
	r, ok := cache.GetByName(user.Name)
	if ok {
		if user.ID != "" {
			r.ID = user.ID
		}
		if user.Age >= 0 {
			r.Age = user.Age
		}
		return true, nil
	}
	return false, errors.New("not found")
}

// UpdateUserByName update by user struct, my be another struct, PX config POST or PUT.
func (u *UserProvider) UpdateUserByName(ctx context.Context, name string, user *User) (bool, error) {
	println("Req UpdateUserByName data:%#v", user)
	r, ok := cache.GetByName(name)
	if ok {
		if user.ID != "" {
			r.ID = user.ID
		}
		if user.Age >= 0 {
			r.Age = user.Age
		}
		return true, nil
	}
	return false, errors.New("not found")
}

// Reference return reference
func (u *UserProvider) Reference() string {
	return "UserProvider"
}

// JavaClassName return java class name
func (u User) JavaClassName() string {
	return "com.ikurento.user.User"
}

// nolint.
func println(format string, args ...interface{}) {
	fmt.Printf("\033[32;40m"+format+"\033[0m\n", args...)
}