How to use Reset method of globals Package

...58	}59	return spaceRegister60}61func space(spacename string, spaceRegister, shadowSpaceRegister dataformats.SpaceState, in chan dataformats.EntryState, stop chan interface{},62	setReset chan bool, entries map[string]dataformats.EntryState, resetSlot []time.Time) {63	// spaceRegister contains the data to be shared with the clients64	// shadowSpaceRegister is a register copy without adjustments65	once.Do(func() {66		if resetSlot != nil {67			fmt.Printf("*** INFO: Space %v has reset slot set from %v:%v to %v:%v Server Time ***\n",68				spacename, resetSlot[0].Hour(), resetSlot[0].Minute(), resetSlot[1].Hour(), resetSlot[1].Minute())69		} else {70			fmt.Printf("*** INFO: Space %v has not reset slot ***\n", spacename)71		}72		// TODO time check can be removed if a cache is used that has timed preserve of state73		if globals.SaveState {74			if state, err := diskCache.ReadState(spacename); err == nil {75				if time.Now().UnixNano() < state.Ts+int64(globals.MaxStateAge)*1000000000 {76					if state.Id == spacename {77						spaceRegister = state78					} else {79						fmt.Println("*** WARNING: Error reading state for space:", spacename, ". Will assume null state ***")80					}81				} else {82					fmt.Println("*** WARNING: State is too old for space:", spacename, ". Will assume null state ***")83				}84			}85			if state, err := diskCache.ReadShadowState(spacename); err == nil {86				if time.Now().UnixNano() < state.Ts+int64(globals.MaxStateAge)*1000000000 {87					if state.Id == spacename {88						shadowSpaceRegister = state89					} else {90						fmt.Println("*** WARNING: Error reading shadow state for space:", spacename, ". Will assume null state ***")91					}92				} else {93					fmt.Println("*** WARNING: Shadow state is too old for space:", spacename, ". Will assume null state ***")94				}95			}96		}97	})98	defer func() {99		if e := recover(); e != nil {100			fmt.Println(e)101			mlogger.Recovered(globals.SpaceManagerLog,102				mlogger.LoggerData{"spaceManager.space: " + spacename,103					"service terminated and recovered unexpectedly",104					[]int{1}, true})105		}106		go space(spacename, spaceRegister, shadowSpaceRegister, in, stop, setReset, entries, resetSlot)107	}()108	if globals.DebugActive {109		fmt.Printf("Space %v has been started\n", spacename)110	}111	mlogger.Info(globals.SpaceManagerLog,112		mlogger.LoggerData{"spaceManager.entry: " + spacename,113			"service started",114			[]int{0}, true})115	resetDone := false116	avgsManager.LatestData.RLock()117	calculator := avgsManager.LatestData.Channel[spacename]118	avgsManager.LatestData.RUnlock()119	for calculator == nil {120		fmt.Printf("*** INFO: Space %v waiting for calculator to be ready ***\n", spacename)121		time.Sleep(time.Duration(globals.SettleTime*3) * time.Second)122		avgsManager.LatestData.RLock()123		calculator = avgsManager.LatestData.Channel[spacename]124		avgsManager.LatestData.RUnlock()125	}126	for {127		select {128		case spaceRegister.State = <-setReset:129			shadowSpaceRegister.State = spaceRegister.State130			if globals.DebugActive {131				fmt.Printf("State of space %v set to %v\n", spacename, spaceRegister.State)132			}133			setReset <- spaceRegister.State134			if spaceRegister.State {135				mlogger.Info(globals.SpaceManagerLog,136					mlogger.LoggerData{"spaceManager.space: " + spacename,137						"state set to true",138						[]int{0}, true})139			} else {140				mlogger.Info(globals.SpaceManagerLog,141					mlogger.LoggerData{"spaceManager.space: " + spacename,142						"state set to false",143						[]int{0}, true})144			}145		case <-stop:146			if globals.SaveState {147				if err := diskCache.SaveState(spaceRegister); err != nil {148					fmt.Println("Error saving state for space:", spacename)149				} else {150					fmt.Println("Successful saving state for space:", spacename)151					if err := diskCache.SaveShadowState(shadowSpaceRegister); err != nil {152						fmt.Println("Error saving shadow state for space:", spacename)153					} else {154						fmt.Println("Successful saving shadow state for space:", spacename)155					}156				}157			}158			fmt.Println("Closing spaceManager.space:", spacename)159			mlogger.Info(globals.SpaceManagerLog,160				mlogger.LoggerData{"spacxeManager.entry: " + spacename,161					"service stopped",162					[]int{0}, true})163			stop <- nil164		case data := <-in:165			if spaceRegister.State {166				// space is enabled167				// we verify if we are in a reset slot168				resetTime := resetSlot != nil169				if resetTime {170					if inTime, err := others.InClosureTime(resetSlot[0], resetSlot[1]); err != nil {171						mlogger.Warning(globals.SpaceManagerLog,172							mlogger.LoggerData{"entryManager.entry: " + spacename,173								"failed to check reset time",174								[]int{0}, true})175						continue176					} else {177						resetTime = resetTime && inTime178					}179				}180				if resetTime {181					if !resetDone {182						select {183						case calculator <- dataformats.SpaceState{184							Reset: true,185						}:186						case <-time.After(time.Duration(2*globals.SettleTime) * time.Second):187							if globals.DebugActive {188								fmt.Println("entryManager.entry:", spacename, "failed to reset flows")189								os.Exit(0)190							}191							mlogger.Warning(globals.SpaceManagerLog,192								mlogger.LoggerData{Id: "entryManager.entry: " + spacename,193									Message: "failed to reset flows",194									Data:    []int{1}, Aggregate: true})195						}196						resetDone = true197						spaceRegister.Count = 0198						spaceRegister.Ts = time.Now().UnixNano()199						for i, entry := range spaceRegister.Flows {200							entry.Variation = 0201							entry.Flows = make(map[string]dataformats.Flow)202							spaceRegister.Flows[i] = entry203						}204						go func(nd dataformats.SpaceState) {205							_ = coredbs.SaveSpaceData(nd)206						}(spaceRegister)207					}208					// the shadow register is always kept updated209					shadowSpaceRegister = updateRegister(shadowSpaceRegister, data)210					if globals.Shadowing {211						go func(nd dataformats.SpaceState) {212							_ = coredbs.SaveShadowSpaceData(nd)213						}(shadowSpaceRegister)214					}215				} else {216					resetDone = false217					if data.Variation != 0 {218						// data is significant219						// we are in a activity slot220						if _, ok := entries[data.Id]; ok {221							// entry sending data is in the configuration222							data.Reversed = entries[data.Id].Reversed223							timestamp := time.Now().UnixNano()224							// the shadow register is updated with the received data225							shadowSpaceRegister = updateRegister(shadowSpaceRegister, data)226							shadowSpaceRegister.Ts = timestamp227							// the data is updated in case it leads to a negative count if the option is enabled228							if !globals.AcceptNegatives {229								newData := data.Variation230								if data.Reversed {231									newData = -newData232								}233								delta := newData + spaceRegister.Count234								if delta < 0 {235									// the new data brings the final count below zero236									// the total count is updated according to the reversed flag in order to have final count zero237									if data.Reversed {238										data.Variation = spaceRegister.Count239									} else {240										data.Variation = -spaceRegister.Count241									}242									// the new data gate flows are updated according to the delta and the reversed flag243									entry := dataformats.EntryState{244										Id:        data.Id,245										Ts:        data.Ts,246										Variation: data.Variation,247										State:     data.State,248										Reversed:  data.Reversed,249										Flows:     make(map[string]dataformats.Flow),250									}251									for key, value := range data.Flows {252										// since data was duplicated before being sent, we can use a shallow copy253										entry.Flows[key] = value254									}255									// all variations are removed256									for i := range entry.Flows {257										flow := entry.Flows[i]258										flow.Variation = 0259										entry.Flows[i] = flow260									}261									delta = data.Variation262									// the new variation is distributed among all gates in the original data263								finished:264									for delta != 0 {265										for i := range entry.Flows {266											if delta < 0 {267												flow := entry.Flows[i]268												flow.Variation -= 1269												entry.Flows[i] = flow270												delta += 1271											} else if delta > 0 {272												flow := entry.Flows[i]273												flow.Variation += 1274												entry.Flows[i] = flow275												delta -= 1276											} else {277												break finished278											}279										}280									}281									data = entry282								}283							}284							// register is updated with an inspected received data285							spaceRegister = updateRegister(spaceRegister, data)286							// space gets its own timestamp287							spaceRegister.Ts = timestamp288							if globals.DebugActive {289								fmt.Printf("Space %v registry data \n\t%+v\n", spacename, spaceRegister)290							}291							go func(nd dataformats.SpaceState) {292								_ = coredbs.SaveSpaceData(nd)293							}(spaceRegister)294							// we give it little time to transmit the data, it too late data is thrown away295							select {296							case calculator <- spaceRegister:297							case <-time.After(time.Duration(globals.SettleTime) * time.Second):298								if globals.DebugActive {299									fmt.Println("entryManager.entry:", spacename, "data to calculator discarded due to late answer")300									os.Exit(0)301								}302								mlogger.Warning(globals.SpaceManagerLog,303									mlogger.LoggerData{Id: "entryManager.entry: " + spacename,304										Message: "data to calculator discarded due to late answer",305										Data:    []int{1}, Aggregate: true})306							}307							if globals.Shadowing {308								go func(nd dataformats.SpaceState) {309									_ = coredbs.SaveShadowSpaceData(nd)310								}(spaceRegister)311							}312						} else {313							mlogger.Warning(globals.SpaceManagerLog,314								mlogger.LoggerData{Id: "entryManager.entry: " + spacename,315									Message: "data from entry " + data.Id + " not in configuration",316									Data:    []int{0}, Aggregate: true})317						}318					}319				}320			}321		case <-time.After(time.Duration(globals.ResetPeriod) * time.Minute):322			if spaceRegister.State {323				// space is enabled324				// check if it is a reset interval and act accordingly325				resetTime := resetSlot != nil326				if resetTime {327					if inTime, err := others.InClosureTime(resetSlot[0], resetSlot[1]); err != nil {328						mlogger.Warning(globals.SpaceManagerLog,329							mlogger.LoggerData{"entryManager.entry: " + spacename,330								"failed to check reset time",331								[]int{0}, true})332						continue333					} else {334						resetTime = resetTime && inTime335					}336				}337				if resetTime {338					if !resetDone {339						select {340						case calculator <- dataformats.SpaceState{341							Reset: true,342						}:343						case <-time.After(time.Duration(2*globals.SettleTime) * time.Second):344							if globals.DebugActive {345								fmt.Println("entryManager.entry:", spacename, "failed to reset flows")346								os.Exit(0)347							}348							mlogger.Warning(globals.SpaceManagerLog,349								mlogger.LoggerData{Id: "entryManager.entry: " + spacename,350									Message: "failed to reset flows",351									Data:    []int{1}, Aggregate: true})352						}353						resetDone = true354						spaceRegister.Count = 0355						spaceRegister.Ts = time.Now().UnixNano()...

...8	"strconv"9	"strings"10	"time"11)12func sensorBGReset(forceReset chan string, rst chan interface{}) {13	// return true is successful14	resetFn := func(channels SensorChannel) bool {15		cmd := []byte{CmdAPI["rstbg"].Cmd}16		cmd = append(cmd, codings.Crc8(cmd))17		var res []byte18		select {19		case channels.Commands <- cmd:20			select {21			case res = <-channels.Commands:22			case <-time.After(time.Duration(globals.SensorTimeout) * time.Second):23			case <-rst:24				fmt.Println("Closing sensorManager.sensorBGReset")25				mlogger.Info(globals.SensorManagerLog,26					mlogger.LoggerData{"sensorManager.sensorBGReset",27						"service stopped",28						[]int{0}, true})29				rst <- nil30			}31		case <-time.After(time.Duration(globals.SensorTimeout) * time.Second):32		}33		return res != nil34	}35	mlogger.Info(globals.SensorManagerLog,36		mlogger.LoggerData{"sensorManager.sensorBGReset",37			"service started",38			[]int{0}, true})39	if globals.ResetSlot != "" {40		var start, stop time.Time41		period := strings.Split(globals.ResetSlot, " ")42		valid := false43		if v, e := time.Parse(globals.TimeLayout, strings.Trim(period[0], " ")); e == nil {44			start = v45			if v, e = time.Parse(globals.TimeLayout, strings.Trim(period[1], " ")); e == nil {46				stop = v47				valid = true48			}49		}50		if valid {51			if globals.DebugActive {52				fmt.Printf("*** INFO: sensor reset is set from %v tp %v\n", start, stop)53			}54			var channels []SensorChannel55			var macs []string56			done := false57			for {58				select {59				case <-rst:60					fmt.Println("Closing sensorManager.sensorBGReset")61					mlogger.Info(globals.SensorManagerLog,62						mlogger.LoggerData{"sensorManager.sensorBGReset",63							"service stopped",64							[]int{0}, true})65					rst <- nil66					return67				case mac := <-forceReset:68					// an answer is not needed back to the reset commander69					ActiveSensors.RLock()70					chs, ok := ActiveSensors.Mac[mac]71					ActiveSensors.RUnlock()72					if ok {73						// reset74						if !resetFn(chs) {75							mlogger.Warning(globals.SensorManagerLog,76								mlogger.LoggerData{"sensorManager.sensorBGReset: mac " + mac,77									"reset has failed",78									[]int{1}, true})79						}80					} else {81						mlogger.Warning(globals.SensorManagerLog,82							mlogger.LoggerData{"sensorManager.sensorBGReset: mac " + mac,83								"reset skipped as sensor not active",84								[]int{0}, true})85					}86				case <-time.After(time.Duration(globals.ResetPeriod) * time.Minute):87					if doIt, e := others.InClosureTime(start, stop); e == nil {88						//  then cycle among all devices till all are reset89						if doIt && !done {90							// we are in the reset interval and we still need to reset91							if channels == nil {92								// in this case we need to load the list of devices to be reset93								ActiveSensors.RLock()94								for k, v := range ActiveSensors.Mac {95									macs = append(macs, k)96									channels = append(channels, v)97								}98								ActiveSensors.RUnlock()99							}100							var channelsLeft []SensorChannel101							var macsLeft []string102							// try to reset all devices103							for i, el := range channels {104								if !resetFn(el) {105									channelsLeft = append(channelsLeft, el)106									macsLeft = append(macsLeft, macs[i])107								} else {108									if globals.DebugActive {109										fmt.Println("sensorManager.sensorBGReset:", macs[i],110											"BG reset executed")111									}112									mlogger.Info(globals.SensorManagerLog,113										mlogger.LoggerData{"sensorManager.sensorBGReset: " + macs[i],114											"BG reset executed",115											[]int{0}, true})116								}117							}118							if channelsLeft != nil {119								copy(channels, channelsLeft)120								copy(macs, macsLeft)121							} else {122								channels = nil123								macs = nil124							}125							if channelsLeft == nil {126								done = true127							}128						} else {129							if !doIt {130								done = false131								if channels != nil {132									mlogger.Warning(globals.SensorManagerLog,133										mlogger.LoggerData{"sensorManager.sensorBGReset",134											"service failed for " + strconv.Itoa(len(channels)) + " sensors",135											[]int{}, false})136									channels = nil137								}138							}139						}140					} else {141						// error142						mlogger.Error(globals.SensorManagerLog,143							mlogger.LoggerData{"sensorManager.sensorBGReset",144								"service failed to initialised new loop",145								[]int{1}, true})146					}147				}148			}149		}150	}151	if globals.DebugActive {152		fmt.Println("*** WARNING: periodic sensor reset is disabled ***")153	}154	// we only listed to reset and forceReset155	for {156		select {157		case <-rst:158			fmt.Println("Closing sensorManager.sensorBGReset")159			mlogger.Info(globals.SensorManagerLog,160				mlogger.LoggerData{"sensorManager.sensorBGReset",161					"service stopped",162					[]int{0}, true})163			rst <- nil164			return165		case mac := <-forceReset:166			// an answer is not needed back to the reset commander167			ActiveSensors.RLock()168			chs, ok := ActiveSensors.Mac[mac]169			ActiveSensors.RUnlock()170			if ok {171				// reset172				if !resetFn(chs) {173					mlogger.Warning(globals.SensorManagerLog,174						mlogger.LoggerData{"sensorManager.sensorBGReset: mac " + mac,175							"reset has failed",176							[]int{1}, true})177				}178			} else {179				mlogger.Warning(globals.SensorManagerLog,180					mlogger.LoggerData{"sensorManager.sensorBGReset: mac " + mac,181						"reset skipped as sensor not active",182						[]int{0}, true})183			}184		}185	}186}...

1/*2 Licensed to the Apache Software Foundation (ASF) under one3 or more contributor license agreements.  See the NOTICE file4 distributed with this work for additional information5 regarding copyright ownership.  The ASF licenses this file6 to you under the Apache License, Version 2.0 (the7 "License"); you may not use this file except in compliance8 with the License.  You may obtain a copy of the License at9     http://www.apache.org/licenses/LICENSE-2.010 Unless required by applicable law or agreed to in writing, software11 distributed under the License is distributed on an "AS IS" BASIS,12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13 See the License for the specific language governing permissions and14 limitations under the License.15*/16package log17import (18	"sync"19	"testing"20	"go.uber.org/zap"21	"go.uber.org/zap/zapcore"22	"gotest.tools/assert"23)24// This test sets the global zap logger. This must be undone to make sure no side25// effects on other tests are caused by running this test.26func TestIsNopLogger(t *testing.T) {27	// reset the global vars and zap logger28	defer resetGlobals()29	testLogger, err := zap.NewDevelopment()30	assert.NilError(t, err, "Dev logger init failed with error")31	assert.Equal(t, false, isNopLogger(testLogger))32	testLogger = zap.NewNop()33	assert.Equal(t, true, isNopLogger(testLogger))34	testLogger = zap.L()35	assert.Equal(t, true, isNopLogger(testLogger))36	testLogger, err = zap.NewProduction()37	assert.NilError(t, err, "Prod logger init failed with error")38	zap.ReplaceGlobals(testLogger)39	assert.Equal(t, false, isNopLogger(testLogger))40	assert.Equal(t, false, isNopLogger(zap.L()))41}42// Since we test the function IsDebugEnabled() we set the logger global var.43// It has not triggered the once.Do() so we just need to make sure we clean up the44// global var.45func TestIsDebugEnabled(t *testing.T) {46	// reset the global vars and zap logger47	defer resetGlobals()48	zapConfig := zap.Config{49		Level:    zap.NewAtomicLevelAt(zapcore.DebugLevel),50		Encoding: "console",51	}52	var err error53	logger, err = zapConfig.Build()54	assert.NilError(t, err, "debug level logger create failed")55	assert.Equal(t, true, IsDebugEnabled())56	zapConfig = zap.Config{57		Level:    zap.NewAtomicLevelAt(zapcore.InfoLevel),58		Encoding: "console",59	}60	logger, err = zapConfig.Build()61	assert.NilError(t, err, "info level logger create failed")62	assert.Equal(t, false, IsDebugEnabled())63}64// reset the global vars and the global logger in zap65func resetGlobals() {66	logger = nil67	config = nil68	once = sync.Once{}69	zap.ReplaceGlobals(zap.NewNop())70}71// This test triggers the once.Do() and will have an impact on other tests in this file.72// resetGlobals() will not undo the impact this test has.73func TestCreateConfig(t *testing.T) {74	defer resetGlobals()75	// direct call76	zapConfig := createConfig()77	localLogger, err := zapConfig.Build()78	assert.NilError(t, err, "default config logger create failed")79	assert.Equal(t, true, localLogger.Core().Enabled(zap.DebugLevel))80	// indirect call to init logger81	assert.Assert(t, logger == nil, "global logger should not have been set %v", logger)82	localLogger = Logger()83	assert.Assert(t, localLogger != nil, "returned logger should have been not nil")84	// default log level is debug85	assert.Equal(t, true, IsDebugEnabled())86	// change log level to info87	InitAndSetLevel(zap.InfoLevel)88	assert.Equal(t, false, IsDebugEnabled())89}90func TestInitializeLogger(t *testing.T) {91	defer resetGlobals()92	zapConfig := zap.Config{93		Level:    zap.NewAtomicLevelAt(zapcore.InfoLevel),94		Encoding: "console",95	}96	localLogger, err := zapConfig.Build()97	assert.NilError(t, err, "failed to create local logger")98	localLogger2, err2 := zapConfig.Build()99	assert.NilError(t, err2, "failed to create local logger")100	InitializeLogger(localLogger, &zapConfig)101	assert.Equal(t, Logger(), localLogger)102	// second initialization should not do anything103	InitializeLogger(localLogger2, &zapConfig)104	assert.Equal(t, Logger(), localLogger)105}106func TestChangeValidLogLevel(t *testing.T) {107	defer resetGlobals()108	zapConfig := zap.Config{109		Level:    zap.NewAtomicLevelAt(zapcore.InfoLevel),110		Encoding: "console",111	}112	localLogger, err := zapConfig.Build()113	assert.NilError(t, err, "failed to create local logger")114	InitializeLogger(localLogger, &zapConfig)115	err = SetLogLevel("DEBUG")116	assert.NilError(t, err, "failed to change log level")117	assert.Equal(t, zapConfig.Level.Level(), zapcore.DebugLevel)118	// set again to see that we keep DEBUG without issues119	err = SetLogLevel("DEBUG")120	assert.NilError(t, err, "failed to change log level")121	assert.Equal(t, zapConfig.Level.Level(), zapcore.DebugLevel)122}123func TestChangeInvalidLogLevel(t *testing.T) {124	defer resetGlobals()125	zapConfig := zap.Config{126		Level:    zap.NewAtomicLevelAt(zapcore.InfoLevel),127		Encoding: "console",128	}129	localLogger, err := zapConfig.Build()130	assert.NilError(t, err, "default config logger create failed")131	InitializeLogger(localLogger, &zapConfig)132	err = SetLogLevel("INVALID")133	assert.Error(t, err, "failed to change log level, old level active")134}...

1import (2func main() {3	mc := memcache.New("localhost:11211")4	mc.Set(&memcache.Item{Key: "foo", Value: []byte("my value")})5	fmt.Println("Set foo to my value")6	item, err := mc.Get("foo")7	if err != nil {8		fmt.Println("Error getting foo")9	} else {10		fmt.Println("Got foo: ", string(item.Value))11	}12	mc.Delete("foo")13	fmt.Println("Deleted foo")14	item, err = mc.Get("foo")15	if err != nil {16		fmt.Println("Error getting foo")17	} else {18		fmt.Println("Got foo: ", string(item.Value))19	}20}21This is a very simple tutorial on how to use memcached with Go. Memcached is a free and open source, high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load. It is used to speed up dynamic web applications by alleviating database load. Memcached is an in-memory key-value store for small chunks of arbitrary data (strings, objects) from results of database calls, API calls, or page rendering. Memcached is simple yet powerful. It is often described as an “object cache”, since it can store almost any kind of data. Memcached is commonly used to speed up dynamic database-driven websites by caching data and objects in RAM to reduce the number of times an external data source (such as a database or API) must be read. Memcached is a free and open source, high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load. It is used to speed up dynamic web applications by alleviating database load. Memcached is an in-memory key-value store for small chunks of arbitrary data (strings, objects) from results of database calls, API calls, or page rendering. Memcached is simple yet powerful. It is often described as an “object cache”, since it can

1import (2func main() {3	globals.Reset()4	fmt.Println(globals.Get())5}6import (7func main() {8	globals.Set(1)9	fmt.Println(globals.Get())10}11import (12func main() {13    resp, err := http.Get(url)14    if err != nil {15        fmt.Println(err)16    }17    defer resp.Body.Close()18    body, err := ioutil.ReadAll(resp.Body)19    if err != nil {20        fmt.Println(err)21    }22    re := regexp.MustCompile("href=\"([^\"]+)\"")23    links := re.FindAllStringSubmatch(string(body), -1)24    for _, link := range links {25        fmt.Println(link[1])26    }27}28import (29func main() {30    resp, err := http.Get(url)31    if err != nil {32        fmt.Println(err)33    }34    defer resp.Body.Close()35    body, err := ioutil.ReadAll(resp.Body)36    if err != nil {37        fmt.Println(err)38    }

1import (2func main() {3    fmt.Println(globals.Get("a"))4    globals.Reset()5    fmt.Println(globals.Get("a"))6}

1import (2func main() {3	conf, err := config.NewConfig("ini", "conf/app.conf")4	if err != nil {5		fmt.Println("error reading configuration file")6	}7	fmt.Println(conf.String("global::appname"))8	conf.Set("global::appname", "new app name")9	conf.SaveConfigFile("conf/app.conf")10	fmt.Println(conf.String("global::appname"))11}

1import "fmt"2func main() {3    fmt.Println("Hello, playground")4    globals.Reset()5    fmt.Println("Hello, playground")6}7func Reset() {8}

1import (2func main() {3    g.Reset()4    fmt.Println(g)5}6import (7func main() {8    g.Reset()9    fmt.Println(g)10}11{0 0 0}12{0 0 0}13type Globals struct {14}15func (g *Globals) Reset() {16}17import (18func main() {19    g.Reset()20    fmt.Println(g)21}22import (23func main() {24    g.Reset()25    fmt.Println(g)26}27{0 0 0}28{0 0 0}

1import (2func main() {3	globals.Set("name", "Akshay")4	fmt.Println(globals.Get("name"))5	globals.Reset()6	fmt.Println(globals.Get("name"))7}

1import (2func main() {3	globals.Reset()4	fmt.Println("Values after reset")5	fmt.Println("First Name: " + globals.FirstName)6	fmt.Println("Last Name: " + globals.LastName)7	fmt.Println("Age: " + globals.Age)8	fmt.Println("Address: " + globals.Address)9	fmt.Println("City: " + globals.City)10	fmt.Println("State: " + globals.State)11	fmt.Println("Zip: " + globals.Zip)12}13How to use the import statement in Go?14How to use the import statement in Go?

1import (2func main() {3	globals.SetVar("Hello")4	fmt.Println(globals.GetVar())5	globals.Reset()6	fmt.Println(globals.GetVar())7}8func Reset() {9}10import (11func main() {12	globals.SetVar("Hello")13	fmt.Println(globals.GetVar())14	globals.Reset()15	fmt.Println(globals.GetVar())16}