github.com/intfoundation/intchain@v0.0.0-20220727031208-4316ad31ca73/intprotocol/downloader/api.go (about) 1 // Copyright 2015 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package downloader 18 19 import ( 20 "context" 21 "sync" 22 23 ethereum "github.com/intfoundation/intchain" 24 "github.com/intfoundation/intchain/event" 25 "github.com/intfoundation/intchain/rpc" 26 ) 27 28 // PublicDownloaderAPI provides an API which gives information about the current synchronisation status. 29 // It offers only methods that operates on data that can be available to anyone without security risks. 30 type PublicDownloaderAPI struct { 31 d *Downloader 32 mux *event.TypeMux 33 installSyncSubscription chan chan interface{} 34 uninstallSyncSubscription chan *uninstallSyncSubscriptionRequest 35 } 36 37 // NewPublicDownloaderAPI create a new PublicDownloaderAPI. The API has an internal event loop that 38 // listens for events from the downloader through the global event mux. In case it receives one of 39 // these events it broadcasts it to all syncing subscriptions that are installed through the 40 // installSyncSubscription channel. 41 func NewPublicDownloaderAPI(d *Downloader, m *event.TypeMux) *PublicDownloaderAPI { 42 api := &PublicDownloaderAPI{ 43 d: d, 44 mux: m, 45 installSyncSubscription: make(chan chan interface{}), 46 uninstallSyncSubscription: make(chan *uninstallSyncSubscriptionRequest), 47 } 48 49 go api.eventLoop() 50 51 return api 52 } 53 54 // eventLoop runs an loop until the event mux closes. It will install and uninstall new 55 // sync subscriptions and broadcasts sync status updates to the installed sync subscriptions. 56 func (api *PublicDownloaderAPI) eventLoop() { 57 var ( 58 sub = api.mux.Subscribe(StartEvent{}, DoneEvent{}, FailedEvent{}) 59 syncSubscriptions = make(map[chan interface{}]struct{}) 60 ) 61 62 for { 63 select { 64 case i := <-api.installSyncSubscription: 65 syncSubscriptions[i] = struct{}{} 66 case u := <-api.uninstallSyncSubscription: 67 delete(syncSubscriptions, u.c) 68 close(u.uninstalled) 69 case event := <-sub.Chan(): 70 if event == nil { 71 return 72 } 73 74 var notification interface{} 75 switch event.Data.(type) { 76 case StartEvent: 77 notification = &SyncingResult{ 78 Syncing: true, 79 Status: api.d.Progress(), 80 } 81 case DoneEvent, FailedEvent: 82 notification = false 83 } 84 // broadcast 85 for c := range syncSubscriptions { 86 c <- notification 87 } 88 } 89 } 90 } 91 92 // Syncing provides information when this nodes starts synchronising with the Ethereum network and when it's finished. 93 func (api *PublicDownloaderAPI) Syncing(ctx context.Context) (*rpc.Subscription, error) { 94 notifier, supported := rpc.NotifierFromContext(ctx) 95 if !supported { 96 return &rpc.Subscription{}, rpc.ErrNotificationsUnsupported 97 } 98 99 rpcSub := notifier.CreateSubscription() 100 101 go func() { 102 statuses := make(chan interface{}) 103 sub := api.SubscribeSyncStatus(statuses) 104 105 for { 106 select { 107 case status := <-statuses: 108 notifier.Notify(rpcSub.ID, status) 109 case <-rpcSub.Err(): 110 sub.Unsubscribe() 111 return 112 case <-notifier.Closed(): 113 sub.Unsubscribe() 114 return 115 } 116 } 117 }() 118 119 return rpcSub, nil 120 } 121 122 // SyncingResult provides information about the current synchronisation status for this node. 123 type SyncingResult struct { 124 Syncing bool `json:"syncing"` 125 Status ethereum.SyncProgress `json:"status"` 126 } 127 128 // uninstallSyncSubscriptionRequest uninstalles a syncing subscription in the API event loop. 129 type uninstallSyncSubscriptionRequest struct { 130 c chan interface{} 131 uninstalled chan interface{} 132 } 133 134 // SyncStatusSubscription represents a syncing subscription. 135 type SyncStatusSubscription struct { 136 api *PublicDownloaderAPI // register subscription in event loop of this api instance 137 c chan interface{} // channel where events are broadcasted to 138 unsubOnce sync.Once // make sure unsubscribe logic is executed once 139 } 140 141 // Unsubscribe uninstalls the subscription from the DownloadAPI event loop. 142 // The status channel that was passed to subscribeSyncStatus isn't used anymore 143 // after this method returns. 144 func (s *SyncStatusSubscription) Unsubscribe() { 145 s.unsubOnce.Do(func() { 146 req := uninstallSyncSubscriptionRequest{s.c, make(chan interface{})} 147 s.api.uninstallSyncSubscription <- &req 148 149 for { 150 select { 151 case <-s.c: 152 // drop new status events until uninstall confirmation 153 continue 154 case <-req.uninstalled: 155 return 156 } 157 } 158 }) 159 } 160 161 // SubscribeSyncStatus creates a subscription that will broadcast new synchronisation updates. 162 // The given channel must receive interface values, the result can either 163 func (api *PublicDownloaderAPI) SubscribeSyncStatus(status chan interface{}) *SyncStatusSubscription { 164 api.installSyncSubscription <- status 165 return &SyncStatusSubscription{api: api, c: status} 166 }