Forem: Phani Sajja

Gathering Timezone Information in GoLang

Phani Sajja — Sun, 04 Jun 2023 17:25:20 +0000

A timezone refers to a specific region on Earth that follows the same standard time. Typically, a timezone is identified by a combination of the continent, country, or city within that country. Here are some key details related to timezones:

Offset from UTC: Represents the time difference in hours and minutes from Coordinated Universal Time (UTC).
Timezone Abbreviations: Commonly used three-letter abbreviations, such as "IST" (Indian Standard Time) or "EST" (Eastern Standard Time), are associated with timezones.
Daylight Saving Time (DST): Many timezones observe DST, which involves adjusting the clocks forward by one hour during specific periods.
Timezone Name: Each timezone is identified by a specific name that represents its location, such as "Asia/Kolkata" or "America/New_York".

In this article, we will explore how to gather the aforementioned details in GoLang. Our focus will be on gathering timezone information on Linux, macOS, and Windows platforms.

UTC Offset, Abbreviation, and DST

Gathering UTC offset, timezone abbreviation, and DST information in Go is a straightforward process. We can utilize the standard time API to achieve this.

UTC Offset

t := time.Now()
utcOffset := t.Format("-07:00")

Abbreviation

abbr, _ := t.Zone()

DST

isDst := t.IsDST()

Sample values for each of the variables are provided below:

utcOffset: '+05:30' abbr: 'IST' isDst: false

UTC offsets and abbreviations can be ambiguous without additional context. While UTC offsets indicate the time difference between a local time and Coordinated Universal Time (UTC), they do not provide information about the specific time zone or region.

Overlapping offsets: Certain time zones or regions can have identical UTC offsets. For instance, both Eastern Standard Time (EST) in the United States and Eastern Standard Time (EST) in Australia share a UTC-3 offset.
Changes in offsets: UTC offsets can change due to factors such as Daylight Saving Time (DST) or modifications in local time regulations.
Abbreviation conflicts: Time zone abbreviations are not standardized globally, and multiple regions may use the same abbreviation for different time zones. For example, "IST" can refer to Indian Standard Time or Israel Standard Time.

In the next section, we will explore how to gather the IANA (Internet Assigned Numbers Authority) timezone name, which helps to minimize ambiguity.

Timezone Name

IANA timezone names consist of two parts: the region and the location. For example, 'America/New_York' represents the timezone of New York City in the United States, and 'Asia/Kolkata' represents the timezone of Kolkata in India.

Linux and macOS

The '/etc/localtime' file is a system file commonly found in Unix-like operating systems, including Linux and macOS. It is typically a symbolic link that points to the timezone data file associated with the local timezone. On Linux systems, the '/etc/localtime' symbolic link typically points to an active zone file, such as '/usr/share/zoneinfo/Asia/Kolkata', while on macOS it points to '/var/db/timezone/zoneinfo/Asia/Kolkata'.

By examining the paths mentioned above, we can determine that the file contains the relevant information about the local timezone, specifically for the Asia/Kolkata timezone.

The following code sample demonstrates reading the timezone information by following the '/etc/localtime' link:

func GetIanaName() (string, error) {
    linkPath := "/etc/localtime"
    targetPath, err := os.Readlink(linkPath)
    if err != nil {
        return "", err
    }

    tzParts := strings.Split(targetPath, "/")
    if len(tzParts) < 3 {
        return "", errors.New("invalid timezone format")
    }

    continent, country := tzParts[len(tzParts)-2], tzParts[len(tzParts)-1]
    timezone := fmt.Sprintf("%s/%s", continent, country)

    _, err = time.LoadLocation(timezone)
    if err != nil {
        return "", err
    }

    return timezone, nil
}

Windows

The 'systeminfo' command on Windows includes the 'Time Zone' data, as shown in the output below:
... Time Zone: (UTC+05:30) Chennai, Kolkata, Mumbai, New Delhi ...

We require a mapping between the Windows timezone names and their corresponding IANA timezone names, as illustrated in the snippet below:

{
    ...
    "(UTC+05:30) Chennai, Kolkata, Mumbai, New Delhi": "Asia/Kolkata",
    ...
}

Creating this mapping is a manual process, and the link contains the reference for the mappings. To establish this mapping, you can find the necessary information by visiting the link.

The following snippet demonstrates how to extract the 'Time Zone' value on Windows:

func GetIanaName() (string, error) {
    cmd := exec.Command("systeminfo")

    output, err := cmd.Output()
    if err != nil {
        return "", err
    }

    timezone := parseTimezone(string(output))

    return GetIanaNameForWindowsName(timezone)
}

func parseTimezone(output string) string {
    lines := strings.Split(output, "\n")
    for _, line := range lines {
        if strings.HasPrefix(line, "Time Zone:") {
            parts := strings.Split(line, ":")
            if len(parts) == 2 {
                return strings.TrimSpace(parts[1])
            }
        }
    }

    return ""
}

Once we obtain the Windows timezone name, we can utilize the mapping file mentioned earlier to find the corresponding IANA timezone name. The following snippet demonstrates this:

type WindowsZoneMapping struct {
    WindowsTimezone string
    IANATimezone    string
}

func GetIanaNameForWindowsName(windowsName string) (string, error) {
    file, err := Resources.Open("resources/windows2iana.json")
    if err != nil {
        return "", err
    }

    r := bufio.NewReader(file)
    decoder := json.NewDecoder(r)
    var m map[string]string
    err = decoder.Decode(&m)
    if err != nil {
        return "", err
    }

    return m[windowsName], err
}

The complete code for this functionality can be found in the GitHub repository here.

Summary

In this article, we have explored timezones and how to retrieve timezone data in Go. We have also examined some of the challenges and ambiguities that can arise when dealing with timezone information. Depending on specific requirements, it may be necessary to use a combination of different timezone values to address these ambiguities effectively.

Golang: Marshaling/Unmarshaling String Values and Arrays

Phani Sajja — Sun, 21 May 2023 10:07:08 +0000

In this article, we will delve into the process of marshaling and unmarshaling a JSON property that has the flexibility to hold either a single value or an array of values. For the sake of simplicity, our emphasis will be on handling JSON data that can be marshaled or unmarshaled as a single string or an array of strings.

Background

Let's consider a situation where we map the WHERE clause to its corresponding JSON representation. In the WHERE clause, specific operators accept a single value, while others accept an array of values. To address this scenario, we can utilize the following JSON structure.

{
  "name": "...",
  "operator": "...",
  "value": ....
}

We can address this situation using various methods. One solution is to accept an array of values. Another approach is to allow for either a single value or an array. The first approach does not require any special handling during marshaling or unmarshaling. However, the second approach requires custom marshaling and unmarshaling. This article will further explore and discuss the second approach in detail.

Consider an example where we have the following JSON:

{
  "name": "City",
  "operator": "=",
  "value": "Seattle"
}

Which can be roughly translated into a WHERE condition, as shown below:
... WHERE City = 'Seattle' ...

Consider another example where we have the following JSON:

{
  "name": "City",
  "operator": "IN",
  "value": ["Seattle", "Butte"]
}

Which can be roughly translated into a WHERE condition, as shown below:
... WHERE City IN ('Seattle', 'Butte') ...

As illustrated in the preceding examples, we have the capability to accommodate either a single string value or an array of string values for the "value" property.

Approach

We can model the above JSON in Go using the code snippet below:

type Filter struct {
    Name     string `json:"name"`
    Operator string `json:"operator"`
    Value    Value  `json:"value"`
}

type Value []string

As you can see from the above snippet, the "value" field is of type string slice.

We can unmarshal the "value" from JSON into a variable of type "Value," as demonstrated in the snippet below:

func (v *Value) UnmarshalJSON(data []byte) error {
    if string(data) == "null" || string(data) == `""` {
        return nil
    }

    var iface interface{}
    err := json.Unmarshal(data, &iface)
    if err != nil {
        return err
    }

    switch value := iface.(type) {
    case string:
        *v = Value([]string{value})
        return nil
    case []interface{}:
        vals := make([]string, 0, len(value))
        for _, v := range value {
            val, ok := v.(string)
            if !ok {
                return errors.New("invalid value in array")
            }
            vals = append(vals, val)
        }
        *v = Value(vals)

        return nil
    }

    return errors.New("invalid value type")
}

The marshaling process is demonstrated in the code snippet below:

func (f Filter) MarshalJSON() ([]byte, error) {
    var v interface{}
    if isArrayOperator(f.Operator) {
        v = f.Value
    } else {
        v = strings.Join(f.Value, ",")
    }

    return json.Marshal(map[string]interface{}{
        "name":     f.Name,
        "operator": f.Operator,
        "value":    v,
    })
}

func isArrayOperator(oper string) bool {
    oper = strings.ToUpper(oper)
    if oper == "IN" || oper == "NOT IN" {
        return true
    }

    return false
}

Note: Observe that we have marshaled the Filter struct, not the value type. Here, we can leverage the presence of the operator field to marshal the value accordingly.

The complete code can be found in this gist.

In the above solution, marshaling is determined by the presence of the operator property, may not always hold. To address this, the following code snippet presents an alternative approach for marshaling the value type.

func (v Value) MarshalJSON() ([]byte, error) {
    if len(v) == 0 {
        return json.Marshal("")
    }

    if len(v) == 1 {
        return json.Marshal(v[0])
    }

    var vals []string = []string(v)
    return json.Marshal(vals)
}

In summary, this article provides a technique for custom marshaling and unmarshaling of a value that can either be a string or an array of strings.