How to use Swap method of config Package

...73	swapEnabled       bool74	netStore          *storage.NetStore75	sfs               *fuse.SwarmFS // need this to cleanup all the active mounts on node exit76	ps                *pss.Pss77	swap              *swap.Swap78	stateStore        *state.DBStore79	accountingMetrics *protocols.AccountingMetrics80	tracerClose io.Closer81}82type SwarmAPI struct {83	Api     *api.API84	Backend chequebook.Backend85}86func (self *Swarm) API() *SwarmAPI {87	return &SwarmAPI{88		Api:     self.api,89		Backend: self.backend,90	}91}92// creates a new swarm service instance93// implements node.Service94// If mockStore is not nil, it will be used as the storage for chunk data.95// MockStore should be used only for testing.96func NewSwarm(config *api.Config, mockStore *mock.NodeStore) (self *Swarm, err error) {97	if bytes.Equal(common.FromHex(config.PublicKey), storage.ZeroAddr) {98		return nil, fmt.Errorf("empty public key")99	}100	if bytes.Equal(common.FromHex(config.BzzKey), storage.ZeroAddr) {101		return nil, fmt.Errorf("empty bzz key")102	}103	var backend chequebook.Backend104	if config.SwapAPI != "" && config.SwapEnabled {105		log.Info("connecting to SWAP API", "url", config.SwapAPI)106		backend, err = ethclient.Dial(config.SwapAPI)107		if err != nil {108			return nil, fmt.Errorf("error connecting to SWAP API %s: %s", config.SwapAPI, err)109		}110	}111	self = &Swarm{112		config:     config,113		backend:    backend,114		privateKey: config.ShiftPrivateKey(),115	}116	log.Debug("Setting up Swarm service components")117	config.HiveParams.Discovery = true118	bzzconfig := &network.BzzConfig{119		NetworkID:   config.NetworkID,120		OverlayAddr: common.FromHex(config.BzzKey),121		HiveParams:  config.HiveParams,122		LightNode:   config.LightNodeEnabled,123	}124	self.stateStore, err = state.NewDBStore(filepath.Join(config.Path, "state-store.db"))125	if err != nil {126		return127	}128	// set up high level api129	var resolver *api.MultiResolver130	if len(config.EnsAPIs) > 0 {131		opts := []api.MultiResolverOption{}132		for _, c := range config.EnsAPIs {133			tld, endpoint, addr := parseEnsAPIAddress(c)134			r, err := newEnsClient(endpoint, addr, config, self.privateKey)135			if err != nil {136				return nil, err137			}138			opts = append(opts, api.MultiResolverOptionWithResolver(r, tld))139		}140		resolver = api.NewMultiResolver(opts...)141		self.dns = resolver142	}143	lstore, err := storage.NewLocalStore(config.LocalStoreParams, mockStore)144	if err != nil {145		return nil, err146	}147	self.netStore, err = storage.NewNetStore(lstore, nil)148	if err != nil {149		return nil, err150	}151	to := network.NewKademlia(152		common.FromHex(config.BzzKey),153		network.NewKadParams(),154	)155	delivery := stream.NewDelivery(to, self.netStore)156	self.netStore.NewNetFetcherFunc = network.NewFetcherFactory(delivery.RequestFromPeers, config.DeliverySkipCheck).New157	if config.SwapEnabled {158		balancesStore, err := state.NewDBStore(filepath.Join(config.Path, "balances.db"))159		if err != nil {160			return nil, err161		}162		self.swap = swap.New(balancesStore)163		self.accountingMetrics = protocols.SetupAccountingMetrics(10*time.Second, filepath.Join(config.Path, "metrics.db"))164	}165	var nodeID enode.ID166	if err := nodeID.UnmarshalText([]byte(config.NodeID)); err != nil {167		return nil, err168	}169	syncing := stream.SyncingAutoSubscribe170	if !config.SyncEnabled || config.LightNodeEnabled {171		syncing = stream.SyncingDisabled172	}173	retrieval := stream.RetrievalEnabled174	if config.LightNodeEnabled {175		retrieval = stream.RetrievalClientOnly176	}177	registryOptions := &stream.RegistryOptions{178		SkipCheck:       config.DeliverySkipCheck,179		Syncing:         syncing,180		Retrieval:       retrieval,181		SyncUpdateDelay: config.SyncUpdateDelay,182		MaxPeerServers:  config.MaxStreamPeerServers,183	}184	self.streamer = stream.NewRegistry(nodeID, delivery, self.netStore, self.stateStore, registryOptions, self.swap)185	// Swarm Hash Merklised Chunking for Arbitrary-length Document/File storage186	self.fileStore = storage.NewFileStore(self.netStore, self.config.FileStoreParams)187	var feedsHandler *feed.Handler188	fhParams := &feed.HandlerParams{}189	feedsHandler = feed.NewHandler(fhParams)190	feedsHandler.SetStore(self.netStore)191	lstore.Validators = []storage.ChunkValidator{192		storage.NewContentAddressValidator(storage.MakeHashFunc(storage.DefaultHash)),193		feedsHandler,194	}195	err = lstore.Migrate()196	if err != nil {197		return nil, err198	}199	log.Debug("Setup local storage")200	self.bzz = network.NewBzz(bzzconfig, to, self.stateStore, self.streamer.GetSpec(), self.streamer.Run)201	// Pss = postal service over swarm (devp2p over bzz)202	self.ps, err = pss.NewPss(to, config.Pss)203	if err != nil {204		return nil, err205	}206	if pss.IsActiveHandshake {207		pss.SetHandshakeController(self.ps, pss.NewHandshakeParams())208	}209	self.api = api.NewAPI(self.fileStore, self.dns, feedsHandler, self.privateKey)210	self.sfs = fuse.NewSwarmFS(self.api)211	log.Debug("Initialized FUSE filesystem")212	return self, nil213}214// parseEnsAPIAddress parses string according to format215// [tld:][contract-addr@]url and returns ENSClientConfig structure216// with endpoint, contract address and TLD.217func parseEnsAPIAddress(s string) (tld, endpoint string, addr common.Address) {218	isAllLetterString := func(s string) bool {219		for _, r := range s {220			if !unicode.IsLetter(r) {221				return false222			}223		}224		return true225	}226	endpoint = s227	if i := strings.Index(endpoint, ":"); i > 0 {228		if isAllLetterString(endpoint[:i]) && len(endpoint) > i+2 && endpoint[i+1:i+3] != "//" {229			tld = endpoint[:i]230			endpoint = endpoint[i+1:]231		}232	}233	if i := strings.Index(endpoint, "@"); i > 0 {234		addr = common.HexToAddress(endpoint[:i])235		endpoint = endpoint[i+1:]236	}237	return238}239// ensClient provides functionality for api.ResolveValidator240type ensClient struct {241	*ens.ENS242	*ethclient.Client243}244// newEnsClient creates a new ENS client for that is a consumer of245// a ENS API on a specific endpoint. It is used as a helper function246// for creating multiple resolvers in NewSwarm function.247func newEnsClient(endpoint string, addr common.Address, config *api.Config, privkey *ecdsa.PrivateKey) (*ensClient, error) {248	log.Info("connecting to ENS API", "url", endpoint)249	client, err := rpc.Dial(endpoint)250	if err != nil {251		return nil, fmt.Errorf("error connecting to ENS API %s: %s", endpoint, err)252	}253	ethClient := ethclient.NewClient(client)254	ensRoot := config.EnsRoot255	if addr != (common.Address{}) {256		ensRoot = addr257	} else {258		a, err := detectEnsAddr(client)259		if err == nil {260			ensRoot = a261		} else {262			log.Warn(fmt.Sprintf("could not determine ENS contract address, using default %s", ensRoot), "err", err)263		}264	}265	transactOpts := bind.NewKeyedTransactor(privkey)266	dns, err := ens.NewENS(transactOpts, ensRoot, ethClient)267	if err != nil {268		return nil, err269	}270	log.Debug(fmt.Sprintf("-> Swarm Domain Name Registrar %v @ address %v", endpoint, ensRoot.Hex()))271	return &ensClient{272		ENS:    dns,273		Client: ethClient,274	}, err275}276// detectEnsAddr determines the ENS contract address by getting both the277// version and genesis hash using the client and matching them to either278// mainnet or testnet addresses279func detectEnsAddr(client *rpc.Client) (common.Address, error) {280	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)281	defer cancel()282	var version string283	if err := client.CallContext(ctx, &version, "net_version"); err != nil {284		return common.Address{}, err285	}286	block, err := ethclient.NewClient(client).BlockByNumber(ctx, big.NewInt(0))287	if err != nil {288		return common.Address{}, err289	}290	switch {291	case version == "1" && block.Hash() == params.MainnetGenesisHash:292		log.Info("using Mainnet ENS contract address", "addr", ens.MainNetAddress)293		return ens.MainNetAddress, nil294	case version == "3" && block.Hash() == params.TestnetGenesisHash:295		log.Info("using Testnet ENS contract address", "addr", ens.TestNetAddress)296		return ens.TestNetAddress, nil297	default:298		return common.Address{}, fmt.Errorf("unknown version and genesis hash: %s %s", version, block.Hash())299	}300}301/*302Start is called when the stack is started303* starts the network kademlia hive peer management304* (starts netStore level 0 api)305* starts DPA level 1 api (chunking -> store/retrieve requests)306* (starts level 2 api)307* starts http proxy server308* registers url scheme handlers for bzz, etc309* TODO: start subservices like sword, swear, swarmdns310*/311// implements the node.Service interface312func (self *Swarm) Start(srv *p2p.Server) error {313	startTime = time.Now()314	self.tracerClose = tracing.Closer315	// update uaddr to correct enode316	newaddr := self.bzz.UpdateLocalAddr([]byte(srv.Self().String()))317	log.Info("Updated bzz local addr", "oaddr", fmt.Sprintf("%x", newaddr.OAddr), "uaddr", fmt.Sprintf("%s", newaddr.UAddr))318	// set chequebook319	//TODO: Currently if swap is enabled and no chequebook (or inexistent) contract is provided, the node would crash.320	//Once we integrate back the contracts, this check MUST be revisited321	if self.config.SwapEnabled && self.config.SwapAPI != "" {322		ctx := context.Background() // The initial setup has no deadline.323		err := self.SetChequebook(ctx)324		if err != nil {325			return fmt.Errorf("Unable to set chequebook for SWAP: %v", err)326		}327		log.Debug(fmt.Sprintf("-> cheque book for SWAP: %v", self.config.Swap.Chequebook()))328	} else {329		log.Debug(fmt.Sprintf("SWAP disabled: no cheque book set"))330	}331	log.Info("Starting bzz service")332	err := self.bzz.Start(srv)333	if err != nil {334		log.Error("bzz failed", "err", err)335		return err336	}337	log.Info("Swarm network started", "bzzaddr", fmt.Sprintf("%x", self.bzz.Hive.BaseAddr()))338	if self.ps != nil {339		self.ps.Start(srv)340	}341	// start swarm http proxy server342	if self.config.Port != "" {343		addr := net.JoinHostPort(self.config.ListenAddr, self.config.Port)344		server := httpapi.NewServer(self.api, self.config.Cors)345		if self.config.Cors != "" {346			log.Debug("Swarm HTTP proxy CORS headers", "allowedOrigins", self.config.Cors)347		}348		log.Debug("Starting Swarm HTTP proxy", "port", self.config.Port)349		go func() {350			err := server.ListenAndServe(addr)351			if err != nil {352				log.Error("Could not start Swarm HTTP proxy", "err", err.Error())353			}354		}()355	}356	self.periodicallyUpdateGauges()357	startCounter.Inc(1)358	self.streamer.Start(srv)359	return nil360}361func (self *Swarm) periodicallyUpdateGauges() {362	ticker := time.NewTicker(updateGaugesPeriod)363	go func() {364		for range ticker.C {365			self.updateGauges()366		}367	}()368}369func (self *Swarm) updateGauges() {370	uptimeGauge.Update(time.Since(startTime).Nanoseconds())371	requestsCacheGauge.Update(int64(self.netStore.RequestsCacheLen()))372}373// implements the node.Service interface374// stops all component services.375func (self *Swarm) Stop() error {376	if self.tracerClose != nil {377		err := self.tracerClose.Close()378		if err != nil {379			return err380		}381	}382	if self.ps != nil {383		self.ps.Stop()384	}385	if ch := self.config.Swap.Chequebook(); ch != nil {386		ch.Stop()387		ch.Save()388	}389	if self.swap != nil {390		self.swap.Close()391	}392	if self.accountingMetrics != nil {393		self.accountingMetrics.Close()394	}395	if self.netStore != nil {396		self.netStore.Close()397	}398	self.sfs.Stop()399	stopCounter.Inc(1)400	self.streamer.Stop()401	err := self.bzz.Stop()402	if self.stateStore != nil {403		self.stateStore.Close()404	}405	return err406}407// implements the node.Service interface408func (self *Swarm) Protocols() (protos []p2p.Protocol) {409	protos = append(protos, self.bzz.Protocols()...)410	if self.ps != nil {411		protos = append(protos, self.ps.Protocols()...)412	}413	return414}415func (self *Swarm) RegisterPssProtocol(spec *protocols.Spec, targetprotocol *p2p.Protocol, options *pss.ProtocolParams) (*pss.Protocol, error) {416	if !pss.IsActiveProtocol {417		return nil, fmt.Errorf("Pss protocols not available (built with !nopssprotocol tag)")418	}419	topic := pss.ProtocolTopic(spec)420	return pss.RegisterProtocol(self.ps, &topic, spec, targetprotocol, options)421}422// implements node.Service423// APIs returns the RPC API descriptors the Swarm implementation offers424func (self *Swarm) APIs() []rpc.API {425	apis := []rpc.API{426		// public APIs427		{428			Namespace: "bzz",429			Version:   "3.0",430			Service:   &Info{self.config, chequebook.ContractParams},431			Public:    true,432		},433		// admin APIs434		{435			Namespace: "bzz",436			Version:   "3.0",437			Service:   api.NewControl(self.api, self.bzz.Hive),438			Public:    false,439		},440		{441			Namespace: "chequebook",442			Version:   chequebook.Version,443			Service:   chequebook.NewApi(self.config.Swap.Chequebook),444			Public:    false,445		},446		{447			Namespace: "swarmfs",448			Version:   fuse.Swarmfs_Version,449			Service:   self.sfs,450			Public:    false,451		},452	}453	apis = append(apis, self.bzz.APIs()...)454	if self.ps != nil {455		apis = append(apis, self.ps.APIs()...)456	}457	return apis458}459func (self *Swarm) Api() *api.API {460	return self.api461}462// SetChequebook ensures that the local checquebook is set up on chain.463func (self *Swarm) SetChequebook(ctx context.Context) error {464	err := self.config.Swap.SetChequebook(ctx, self.backend, self.config.Path)465	if err != nil {466		return err467	}468	log.Info(fmt.Sprintf("new chequebook set (%v): saving config file, resetting all connections in the hive", self.config.Swap.Contract.Hex()))469	return nil470}471// serialisable info about swarm472type Info struct {473	*api.Config474	*chequebook.Params475}476func (self *Info) Info() *Info {477	return self478}...

1package okex2/*3 OKEX ws api websocket test & sample4 @author Lingting Fu5 @date 2018-12-276 @version 1.0.07*/8import (9	"fmt"10	"github.com/stretchr/testify/assert"11	"hash/crc32"12	"testing"13	"time"14)15func TestOKWSAgent_AllInOne(t *testing.T) {16	agent := OKWSAgent{}17	config := GetDefaultConfig()18	// Step1: Start agent.19	agent.Start(config)20	// Step2: Subscribe channel21	// Step2.0: Subscribe public channel swap/ticker successfully.22	agent.Subscribe(CHNL_SWAP_TICKER, "BTC-USD-SWAP", DefaultDataCallBack)23	// Step2.1: Subscribe private channel swap/position before login, so it would be a fail.24	agent.Subscribe(CHNL_SWAP_POSITION, "BTC-USD-SWAP", DefaultDataCallBack)25	// Step3: Wait for the ws server's pushed table responses.26	time.Sleep(60 * time.Second)27	// Step4. Unsubscribe public channel swap/ticker28	agent.UnSubscribe(CHNL_SWAP_TICKER, "BTC-USD-SWAP")29	time.Sleep(1 * time.Second)30	// Step5. Login31	agent.Login(config.ApiKey, config.Passphrase)32	time.Sleep(1 * time.Second)33	// Step6. Subscribe private channel swap/position after login, so it would be a success.34	agent.Subscribe(CHNL_SWAP_POSITION, "BTC-USD-SWAP", DefaultDataCallBack)35	time.Sleep(120 * time.Second)36	// Step7. Stop all the go routine run in background.37	agent.Stop()38	time.Sleep(1 * time.Second)39}40func TestOKWSAgent_Depths(t *testing.T) {41	agent := OKWSAgent{}42	config := GetDefaultConfig()43	// Step1: Start agent.44	agent.Start(config)45	// Step2: Subscribe channel46	// Step2.0: Subscribe public channel swap/depths successfully.47	agent.Subscribe(CHNL_SWAP_DEPTH, "BTC-USD-SWAP", DefaultDataCallBack)48	// Step3: Client receive depths from websocket server.49	// Step3.0: Receive partial depths50	// Step3.1: Receive update depths (It may take a very long time to see Update Event.)51	time.Sleep(60 * time.Second)52	// Step4. Stop all the go routine run in background.53	agent.Stop()54	time.Sleep(1 * time.Second)55}56func TestOKWSAgent_mergeDepths(t *testing.T) {57	oldDepths := [][4]interface{}{58		{"5088.59", "34000", 0, 1},59		{"7200", "1", 0, 1},60		{"7300", "1", 0, 1},61	}62	// Case1.63	newDepths1 := [][4]interface{}{64		{"5088.59", "32000", 0, 1},65	}66	expectedMerged1 := [][4]interface{}{67		{"5088.59", "32000", 0, 1},68		{"7200", "1", 0, 1},69		{"7300", "1", 0, 1},70	}71	m1, e1 := mergeDepths(oldDepths, newDepths1)72	assert.True(t, e1 == nil)73	assert.True(t, len(*m1) == len(expectedMerged1) && (*m1)[0][1] == expectedMerged1[0][1] && (*m1)[0][1] == "32000")74	// Case2.75	newDepths2 := [][4]interface{}{76		{"7200", "0", 0, 1},77	}78	expectedMerged2 := [][4]interface{}{79		{"5088.59", "34000", 0, 1},80		{"7300", "1", 0, 1},81	}82	m2, e2 := mergeDepths(oldDepths, newDepths2)83	assert.True(t, e2 == nil)84	assert.True(t, len(*m2) == len(expectedMerged2) && (*m2)[0][1] == expectedMerged2[0][1] && (*m2)[0][1] == "34000")85	// Case3.86	newDepths3 := [][4]interface{}{87		{"5000", "1", 0, 1},88		{"7400", "1", 0, 1},89	}90	expectedMerged3 := [][4]interface{}{91		{"5000", "1", 0, 1},92		{"5088.59", "34000", 0, 1},93		{"7200", "1", 0, 1},94		{"7300", "1", 0, 1},95		{"7400", "1", 0, 1},96	}97	m3, e3 := mergeDepths(oldDepths, newDepths3)98	assert.True(t, e3 == nil)99	assert.True(t, len(*m3) == len(expectedMerged3) && (*m3)[0][1] == expectedMerged3[0][1] && (*m3)[0][1] == "1")100}101func TestOKWSAgent_calCrc32(t *testing.T) {102	askDepths := [][4]interface{}{103		{"5088.59", "34000", 0, 1},104		{"7200", "1", 0, 1},105		{"7300", "1", 0, 1},106	}107	bidDepths1 := [][4]interface{}{108		{"3850", "1", 0, 1},109		{"3800", "1", 0, 1},110		{"3500", "1", 0, 1},111		{"3000", "1", 0, 1},112	}113	crcBuf1, caled1 := calCrc32(&askDepths, &bidDepths1)114	assert.True(t, caled1 != 0 && crcBuf1.String() == "3850:1:3800:1:3500:1:3000:1:5088.59:34000:7200:1:7300:1")115	bidDepths2 := [][4]interface{}{116		{"3850", "1", 0, 1},117		{"3800", "1", 0, 1},118		{"3500", "1", 0, 1},119	}120	crcBuf2, caled2 := calCrc32(&askDepths, &bidDepths2)121	assert.True(t, caled2 != 0 && crcBuf2.String() == "3850:1:5088.59:34000:3800:1:7200:1:3500:1:7300:1")122}123func TestArray(t *testing.T) {124	t1 := [4]int{1, 2, 3, 4}125	t2 := [][4]int{126		{1, 2, 3, 4},127	}128	t3 := [4][]int{129		{1, 2, 3, 4},130	}131	r1, _ := Struct2JsonString(t1)132	r2, _ := Struct2JsonString(t2)133	r3, _ := Struct2JsonString(t3)134	println(len(t1), r1)135	println(len(t2), r2)136	println(len(t3), r3)137	fmt.Printf("%+v", t1[0:len(t1)-1])138}139func TestCrc32(t *testing.T) {140	str1 := "3366.1:7:3366.8:9:3366:6:3368:8"141	r := crc32.ChecksumIEEE([]byte(str1))142	println(r)143	assert.True(t, int32(r) == -1881014294)144	str2 := "3366.1:7:3366.8:9:3368:8:3372:8"145	r = crc32.ChecksumIEEE([]byte(str2))146	println(r)147	assert.True(t, int32(r) == 831078360)148}149func TestFmtSprintf(t *testing.T) {150	a := [][]interface{}{151		{"199", "10"},152		{199.0, 10.0},153	}154	for _, v := range a {155		s1 := fmt.Sprintf("%v:%v", v[0], v[1])156		s2 := fmt.Sprintf("%s:%s", v[0], v[1])157		println(s1)158		println(s2)159		assert.True(t, s1 != "" && s2 != "")160	}161}162func TestOKWSAgent_Futures_AllInOne(t *testing.T) {163	agent := OKWSAgent{}164	config := GetDefaultConfig()165	publicChannels := []string{166		CHNL_FUTURES_CANDLE60S,167		CHNL_FUTURES_CANDLE180S,168		CHNL_FUTURES_CANDLE300S,169		CHNL_FUTURES_CANDLE900S,170		CHNL_FUTURES_CANDLE1800S,171		CHNL_FUTURES_CANDLE3600S,172		CHNL_FUTURES_CANDLE7200S,173		CHNL_FUTURES_CANDLE14400S,174		CHNL_FUTURES_DEPTH,175		CHNL_FUTURES_DEPTH5,176		CHNL_FUTURES_ESTIMATED_PRICE,177		CHNL_FUTURES_MARK_PRICE,178		CHNL_FUTURES_PRICE_RANGE,179		CHNL_FUTURES_TICKER,180		CHNL_FUTURES_TRADE,181	}182	privateChannels := []string{183		CHNL_FUTURES_ACCOUNT,184		CHNL_FUTURES_ORDER,185		CHNL_FUTURES_POSITION,186	}187	filter := "BTC-USD-170310"188	// Step1: Start agent.189	agent.Start(config)190	// Step2: Login191	agent.Login(config.ApiKey, config.Passphrase)192	time.Sleep(1 * time.Second)193	// Step3: Subscribe privateChannels194	for _, c := range privateChannels {195		agent.Subscribe(c, filter, DefaultDataCallBack)196	}197	// Step4: Subscribe publicChannels198	for _, c := range publicChannels {199		agent.Subscribe(c, filter, DefaultDataCallBack)200	}201	time.Sleep(time.Second * 2)202	// Step5: unsubscribe privateChannels203	for _, c := range privateChannels {204		agent.UnSubscribe(c, filter)205	}206	agent.Stop()207}208func TestOKWSAgent_Spots_AllInOne(t *testing.T) {209	agent := OKWSAgent{}210	config := GetDefaultConfig()211	publicChannels := []string{212		CHNL_SPOT_CANDLE60S,213		CHNL_SPOT_CANDLE180S,214		CHNL_SPOT_CANDLE300S,215		CHNL_SPOT_CANDLE900S,216		CHNL_SPOT_CANDLE1800S,217		CHNL_SPOT_CANDLE3600S,218		CHNL_SPOT_CANDLE7200S,219		CHNL_SPOT_CANDLE14400S,220		CHNL_SPOT_DEPTH,221		CHNL_SPOT_DEPTH5,222		CHNL_SPOT_TICKER,223		CHNL_SPOT_TRADE,224	}225	privateChannels := []string{226		CHNL_SPOT_ACCOUNT,227		CHNL_SPOT_MARGIN_ACCOUNT,228		CHNL_SPOT_ORDER,229	}230	filter := "ETH-USDT"231	// Step1: Start agent.232	agent.Start(config)233	// Step2: Login234	agent.Login(config.ApiKey, config.Passphrase)235	time.Sleep(1 * time.Second)236	// Step3: Subscribe privateChannels237	for _, c := range privateChannels {238		agent.Subscribe(c, filter, DefaultDataCallBack)239	}240	// Step4: Subscribe publicChannels241	for _, c := range publicChannels {242		agent.Subscribe(c, filter, DefaultDataCallBack)243	}244	time.Sleep(time.Second * 2)245	// Step5: unsubscribe privateChannels246	for _, c := range privateChannels {247		agent.UnSubscribe(c, filter)248	}249	agent.Stop()250}...

...17	"github.com/binance-chain/eth-swap-ap/restapi/operations/svc_info"18	"github.com/binance-chain/eth-swap-ap/restapi/operations/swap_pairs"19	"github.com/binance-chain/eth-swap-ap/restapi/operations/swap_sms"20	"github.com/binance-chain/eth-swap-ap/restapi/operations/swaps"21	SwapPairsSm "github.com/binance-chain/eth-swap-ap/restapi/swap_pair_sms"22	SwapPairs "github.com/binance-chain/eth-swap-ap/restapi/swap_pairs"23	Swaps "github.com/binance-chain/eth-swap-ap/restapi/swaps"24	"github.com/binance-chain/eth-swap-ap/services"25	"github.com/binance-chain/eth-swap-ap/utils/cache"26	uenv "github.com/binance-chain/eth-swap-ap/utils/env"27	"github.com/binance-chain/eth-swap-ap/utils/log"28)29//go:generate swagger generate server --target ../../eth-swap-ap --name EthSwapAp --spec ../swagger.yml30func configureAPI(api *operations.EthSwapApAPI) http.Handler {31	// configure the api here32	api.ServeError = errors.ServeError33	api.JSONConsumer = runtime.JSONConsumer()34	api.JSONProducer = runtime.JSONProducer()35	api.Logger = func(str string, args ...interface{}) {36		level, str := log.ParsePrefixedLogString(str)37		log.GetLogger(level)(str, args...)38	}39	api.SwapsGetSwapsHandler = swaps.GetSwapsHandlerFunc(func(params swaps.GetSwapsParams) middleware.Responder {40		return swapsCache.Serve(params.HTTPRequest, func() middleware.Responder {41			return Swaps.NewGetSwapsHandler(env, api).Serve(params)42		}, api.JSONProducer)43	})44	api.SwapPairsGetSwapPairsHandler = swap_pairs.GetSwapPairsHandlerFunc(func(params swap_pairs.GetSwapPairsParams) middleware.Responder {45		return swapPairCache.Serve(params.HTTPRequest, func() middleware.Responder {46			return SwapPairs.NewGetSwapPairsHandler(env, api).Serve(params)47		}, api.JSONProducer)48	})49	api.SwapSmsGetSwapPairSmsHandler = swap_sms.GetSwapPairSmsHandlerFunc(func(params swap_sms.GetSwapPairSmsParams) middleware.Responder {50		return swapPairSMCache.Serve(params.HTTPRequest, func() middleware.Responder {51			return SwapPairsSm.NewGetSwapPairSmsHandler(env, api).Serve(params)52		}, api.JSONProducer)53	})54	api.SvcInfoGetInfoHandler = svc_info.GetInfoHandlerFunc(func(params svc_info.GetInfoParams) middleware.Responder {55		return infoCache.Serve(params.HTTPRequest, func() middleware.Responder {56			return rinfo.NewGetInfoHandler(env, api).Serve(params)57		}, api.JSONProducer)58	})59	api.PreServerShutdown = func() {}60	api.ServerShutdown = func() {}61	return setupGlobalMiddleware(api.Serve(setupMiddlewares))62}63// The TLS configuration before HTTPS server starts.64func configureTLS(tlsConfig *tls.Config) {65	// Make all necessary changes to the TLS configuration here.66}67const cacheServiceTickRate = time.Hour68var (69	Log    = logging.MustGetLogger("eth-swap-ap")70	config *cfg.Config71	// services72	cacheService services.Service73	// caches74	swapPairCache,75	swapPairSMCache,76	swapsCache,77	infoCache *middlewares.MWCacher78	//env79	env *uenv.Env80)81var cliOpts = struct {82	ConfigFileName string `short:"c" long:"config-file" description:"Config filename"`83	SecretName     string `short:"s" long:"secret-name" description:"the secret name of the config"`84	SecretRegion   string `short:"r" long:"secret-region" description:"the secret region of the config"`85}{}86func configureFlags(api *operations.EthSwapApAPI) {87	param1 := swag.CommandLineOptionsGroup{88		ShortDescription: "config",89		Options:          &cliOpts,90	}91	api.CommandLineOptionsGroups = []swag.CommandLineOptionsGroup{param1}92}93// As soon as server is initialized but not run yet, this function will be called.94// If you need to modify a config, store server instance to stop it individually later, this is the place.95// This function can be called multiple times, depending on the number of serving schemes.96// scheme value will be set accordingly: "http", "https" or "unix"97func configureServer(s *http.Server, scheme, addr string) {98	configFileName := cliOpts.ConfigFileName99	secretName := cliOpts.SecretName100	secretRegion := cliOpts.SecretRegion101	if configFileName == "" && (secretName == "" || secretRegion == "") {102		panic("missing config file path and secret path")103	}104	if configFileName != "" {105		config = cfg.InitConfigFromFile(configFileName)106	}107	if secretName != "" && secretRegion != "" {108		config = cfg.InitConfigFromSecret(secretName, secretRegion, config)109	}110	// init logger111	log.InitLogger(config.Logs)112	// init cache113	store := cache.NewMemStorage()114	swapPairCacheMS := config.CacheTTLs["swap_pairs"] * time.Millisecond.Nanoseconds()115	swapPairCache = middlewares.NewMWCacher(store, time.Duration(swapPairCacheMS))116	swapsCacheMs := config.CacheTTLs["swaps"] * time.Millisecond.Nanoseconds()117	swapPairSmsCacheMs := config.CacheTTLs["swap_pair_sms"] * time.Millisecond.Nanoseconds()118	swapPairSMCache = middlewares.NewMWCacher(store, time.Duration(swapPairSmsCacheMs))119	swapsCache = middlewares.NewMWCacher(store, time.Duration(swapsCacheMs))120	infoCacheMs := config.CacheTTLs["info"] * time.Millisecond.Nanoseconds()121	infoCache = middlewares.NewMWCacher(store, time.Duration(infoCacheMs))122	cacheService = services.NewCacheService(store, cacheServiceTickRate)123	if err := cacheService.Start(); err != nil {124		panic(err) // fatal125	}126	// init db127	dbConfig := config.DB128	swapPairDao, swapPairSMDao, swapDao, err := dao.NewDaoServices(dbConfig.UserName, dbConfig.Password, dbConfig.Host, dbConfig.DBName, dbConfig.Port, dbConfig.AutoMigrate)129	if err != nil {130		panic(err)131	}132	// init env133	env = &uenv.Env{134		Config:        config,135		SwapPairDao:   swapPairDao,136		SwapPairSMDao: swapPairSMDao,137		SwapDao:       swapDao,138		Cache:         store,139	}140}141// The middleware configuration is for the handler executors. These do not apply to the swagger.json document.142// The middleware executes after routing but before authentication, binding and validation143func setupMiddlewares(handler http.Handler) http.Handler {144	return handler145}146// The middleware configuration happens before anything, this middleware also applies to serving the swagger.json document.147// So this is a good place to plug in a panic handling middleware, logging and metrics148func setupGlobalMiddleware(handler http.Handler) http.Handler {149	return handler150}...

1import (2func main() {3    c, err := config.NewConfig("ini", "conf/app.conf")4    if err != nil {5        fmt.Println(err)6    }7    c.Swap()8    fmt.Println(c.String("appname"))9}10import (11func main() {12    c, err := config.NewConfig("ini", "conf/app.conf")13    if err != nil {14        fmt.Println(err)15    }16    c.Swap()17    fmt.Println(c.String("appname"))18}19import (20func main() {21    c, err := config.NewConfig("ini", "conf/app.conf")22    if err != nil {23        fmt.Println(err)24    }25    c.WatchConfig()26    fmt.Println(c.String("appname"))27}28import (29func main() {30    c, err := config.NewConfig("ini", "conf/app.conf")31    if err != nil {32        fmt.Println(err)33    }34    c.WatchConfig()35    fmt.Println(c.String("appname"))36}

1import (2func main() {3    cfg, err := config.NewConfig("ini", "conf/app.conf")4    if err != nil {5        fmt.Println(err)6    }7    cfg.Set("appname", "beego")8    fmt.Println(cfg.String("appname"))9    fmt.Println(cfg.String("httpport"))10    fmt.Println(cfg.String("runmode"))11    cfg.Set("appname", "beego1")12    cfg.Set("httpport", "8080")13    cfg.Set("runmode", "dev")14    cfg.SaveConfigFile("conf/app.conf")15    cfg.Swap()16    fmt.Println(cfg.String("appname"))17    fmt.Println(cfg.String("httpport"))18    fmt.Println(cfg.String("runmode"))19}

1import (2func main() {3	swap.Swap(&a, &b)4	fmt.Println("a = ", a)5	fmt.Println("b = ", b)6}

1import (2func main() {3	c := config.Config{A: 1, B: 2}4	fmt.Println("Before swap: ", c)5	c.Swap()6	fmt.Println("After swap: ", c)7}8type Config struct {9}10func (c Config) Swap() {11}12Before swap:  {1 2}13After swap:  {1 2}

1import (2func main() {3    fmt.Println("Hello World")4    config := gobuild.NewConfig()5    config.Swap()6}7import (8func main() {9    fmt.Println("Hello World")10    config := gobuild.NewConfig()11    config.Swap()12}13import (14func main() {15    fmt.Println("Hello World")16    config := gobuild.NewConfig()17    config.Swap()18}19import (20func main() {21    fmt.Println("Hello World")22    config := gobuild.NewConfig()23    config.Swap()24}25import (26func main() {27    fmt.Println("Hello World")28    config := gobuild.NewConfig()29    config.Swap()30}31import (32func main() {33    fmt.Println("Hello World")34    config := gobuild.NewConfig()35    config.Swap()36}37import (38func main() {39    fmt.Println("Hello World")40    config := gobuild.NewConfig()41    config.Swap()42}43import (44func main() {45    fmt.Println("Hello World")46    config := gobuild.NewConfig()47    config.Swap()48}