github.com/erda-project/erda-infra@v1.0.9/providers/etcd-mutex/examples/main.go (about)

     1  // Copyright (c) 2021 Terminus, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package main
    16  
    17  import (
    18  	"context"
    19  	"fmt"
    20  	"os"
    21  	"sync"
    22  	"time"
    23  
    24  	"github.com/erda-project/erda-infra/base/servicehub"
    25  	mutex "github.com/erda-project/erda-infra/providers/etcd-mutex"
    26  )
    27  
    28  type provider struct {
    29  	Mutex mutex.Interface // autowired
    30  	Lock  mutex.Mutex     `mutex-key:"test-key"` // autowired
    31  }
    32  
    33  func (p *provider) Run(ctx context.Context) error {
    34  	go func() {
    35  		time.Sleep(10 * time.Second)
    36  		err := p.Lock.Close()
    37  		if err != nil {
    38  			fmt.Println("Close err: ", err)
    39  			return
    40  		}
    41  		err = p.Lock.Close()
    42  		if err != nil {
    43  			fmt.Println("Close err: ", err)
    44  			return
    45  		}
    46  	}()
    47  	lock := p.Lock
    48  	sleep := func(d time.Duration) bool {
    49  		select {
    50  		case <-time.After(d):
    51  		case <-ctx.Done():
    52  			return false
    53  		}
    54  		return true
    55  	}
    56  	doTaskInLock := func(prefix string) bool {
    57  		err := lock.Lock(ctx)
    58  		if err != nil {
    59  			fmt.Println("Lock err: ", err)
    60  			return false
    61  		}
    62  		defer func() {
    63  			err := lock.Unlock(context.TODO())
    64  			if err != nil {
    65  				fmt.Println("Unlock err: ", err)
    66  			}
    67  		}()
    68  		fmt.Println(prefix+" {", time.Now())
    69  		if !sleep(1 * time.Second) {
    70  			return false
    71  		}
    72  		fmt.Println(prefix+"    ", time.Now())
    73  		if !sleep(1 * time.Second) {
    74  			return false
    75  		}
    76  		fmt.Println(prefix+" }", time.Now())
    77  		return true
    78  	}
    79  	var wg sync.WaitGroup
    80  	for _, elem := range []string{"A", "B", "C"} {
    81  		wg.Add(1)
    82  		go func(prefix string) {
    83  			defer wg.Done()
    84  			for doTaskInLock(prefix) {
    85  			}
    86  		}(elem)
    87  	}
    88  	wg.Wait()
    89  	return nil
    90  }
    91  
    92  func init() {
    93  	servicehub.Register("example", &servicehub.Spec{
    94  		Services:     []string{"example"},
    95  		Dependencies: []string{"etcd-mutex"},
    96  		Description:  "example",
    97  		Creator: func() servicehub.Provider {
    98  			return &provider{}
    99  		},
   100  	})
   101  }
   102  
   103  func main() {
   104  	hub := servicehub.New()
   105  	hub.Run("examples", "", os.Args...)
   106  }
   107  
   108  // OUTPUT:
   109  // INFO[2021-09-13 17:13:51.818] provider etcd initialized
   110  // INFO[2021-09-13 17:13:51.818] provider etcd-mutex (depends services: [etcd]) initialized
   111  // INFO[2021-09-13 17:13:51.818] provider example (depends services: [etcd-mutex], providers: [etcd-mutex etcd-mutex]) initialized
   112  // INFO[2021-09-13 17:13:51.818] signals to quit: [hangup interrupt terminated quit]
   113  // INFO[2021-09-13 17:13:51.820] provider example running ...
   114  // A { 2021-09-13 17:13:51.846363 +0800 CST m=+0.082408900
   115  // A     2021-09-13 17:13:52.847656 +0800 CST m=+1.083695286
   116  // A } 2021-09-13 17:13:53.848607 +0800 CST m=+2.084640009
   117  // C { 2021-09-13 17:13:53.872487 +0800 CST m=+2.108520071
   118  // C     2021-09-13 17:13:54.87288 +0800 CST m=+3.108907011
   119  // C } 2021-09-13 17:13:55.874864 +0800 CST m=+4.110884363
   120  // B { 2021-09-13 17:13:55.898284 +0800 CST m=+4.134303984
   121  // B     2021-09-13 17:13:56.902232 +0800 CST m=+5.138246123
   122  // B } 2021-09-13 17:13:57.904445 +0800 CST m=+6.140452108
   123  // A { 2021-09-13 17:13:57.925672 +0800 CST m=+6.161679201
   124  // A     2021-09-13 17:13:58.930195 +0800 CST m=+7.166196424
   125  // A } 2021-09-13 17:13:59.933883 +0800 CST m=+8.169877844
   126  // C { 2021-09-13 17:13:59.956048 +0800 CST m=+8.192042605
   127  // C     2021-09-13 17:14:00.960022 +0800 CST m=+9.196010725
   128  // Lock err:  mutex closed
   129  // Lock err:  mutex closed
   130  // Lock err:  mutex closed
   131  // INFO[2021-09-13 17:14:01.963] provider example Run exit