golang – 水色（仮）

2023年4月20日2023年4月20日

golang で UPnP をサポートするルーターを検出し、ルーターの外部ポートをローカル PC の転送ポートにマップする / Detects routers that support UPnP and maps the router’s external ports to forward ports on the local PC with golang

下記のパッケージで機能が提供されています：

https://github.com/huin/goupnp
https://gitlab.com/NebulousLabs/go-upnp
https://gitlab.com/NebulousLabs/fastrand

gitlab.com/NebulousLabs/go-upnp は、このままでは
現在の github.com/huin/goupnp とマッチしないので
ローカルの upnp/upnp.go に必要な箇所をコピーして修正して使用しました。

最低限のソースのみ

upnp/upnp.go:

// Package upnp provides a simple and opinionated interface to UPnP-enabled
// routers, allowing users to forward ports and discover their external IP
// address. Specific quirks:
//
// - When attempting to discover UPnP-enabled routers on the network, only the
// first such router is returned. If you have multiple routers, this may cause
// some trouble. But why would you do that?
//
// - Forwarded ports are always symmetric, e.g. the router's port 9980 will be
// mapped to the client's port 9980. This will be unacceptable for some
// purposes, but too bad. Symmetric mappings are the desired behavior 99% of
// the time, and they save a function argument.
//
// - TCP and UDP protocols are forwarded together.
//
// - Ports are forwarded permanently. Some other implementations lease a port
// mapping for a set duration, and then renew it periodically. This is nice,
// because it means mappings won't stick around after they've served their
// purpose. Unfortunately, some routers only support permanent mappings, so this
// package has chosen to support the lowest common denominator. To un-forward a
// port, you must use the Clear function (or do it manually).
//
// Once you've discovered your router, you can retrieve its address by calling
// its Location method. This address can be supplied to Load to connect to the
// router directly, which is much faster than calling Discover.
package upnp

import (
	"context"
	"errors"
	"net/url"
	"time"

	"gitlab.com/NebulousLabs/fastrand"

	"github.com/huin/goupnp"
	"github.com/huin/goupnp/dcps/internetgateway1"
)

// An IGD provides an interface to the most commonly used functions of an
// Internet Gateway Device: discovering the external IP, and forwarding ports.
type IGD struct {
	// This interface is satisfied by the internetgateway1.WANIPConnection1
	// and internetgateway1.WANPPPConnection1 types.
	client interface {
		GetExternalIPAddress() (string, error)
		AddPortMapping(string, uint16, string, uint16, string, bool, string, uint32) error
		GetSpecificPortMappingEntry(string, uint16, string) (uint16, string, bool, string, uint32, error)
		DeletePortMapping(string, uint16, string) error
		GetServiceClient() *goupnp.ServiceClient
	}
}

// ExternalIP returns the router's external IP.
func (d *IGD) ExternalIP() (string, error) {
	return d.client.GetExternalIPAddress()
}

// Forward forwards the specified protcol, port, and adds its description to the
// router's port mapping table.
func (d *IGD) Forward(routerPort uint16, protcol string, destIP string, destPort uint16, desc string) error {
	time.Sleep(time.Millisecond)
	return d.client.AddPortMapping("", routerPort, protcol, destPort, destIP, true, desc, 0)
}

// Clear un-forwards a port, removing it from the router's port mapping table.
func (d *IGD) Clear(port uint16, protcol string) error {
	time.Sleep(time.Millisecond)
	return d.client.DeletePortMapping("", port, protcol)
}

// Discover is deprecated; use DiscoverCtx instead.
func Discover() (*IGD, error) {
	return DiscoverCtx(context.Background())
}

// DiscoverCtx scans the local network for routers and returns the first
// UPnP-enabled router it encounters.  It will try up to 3 times to find a
// router, sleeping a random duration between each attempt.  This is to
// mitigate a race condition with many callers attempting to discover
// simultaneously.
func DiscoverCtx(ctx context.Context) (*IGD, error) {
	// TODO: if more than one client is found, only return those on the same
	// subnet as the user?
	maxTries := 3
	sleepTime := time.Millisecond * time.Duration(fastrand.Intn(5000))
	for try := 0; try < maxTries; try++ {
		pppclients, _, _ := internetgateway1.NewWANPPPConnection1Clients()
		if len(pppclients) > 0 {
			return &IGD{pppclients[0]}, nil
		}
		ipclients, _, _ := internetgateway1.NewWANIPConnection1Clients()
		if len(ipclients) > 0 {
			return &IGD{ipclients[0]}, nil
		}
		select {
		case <-ctx.Done():
			return nil, context.Canceled
		case <-time.After(sleepTime):
		}
		sleepTime *= 2
	}
	return nil, errors.New("no UPnP-enabled gateway found")
}

// Load connects to the router service specified by rawurl. This is much
// faster than Discover. Generally, Load should only be called with values
// returned by the IGD's Location method.
func Load(rawurl string) (*IGD, error) {
	loc, err := url.Parse(rawurl)
	if err != nil {
		return nil, err
	}
	pppclients, _ := internetgateway1.NewWANPPPConnection1ClientsByURL(loc)
	if len(pppclients) > 0 {
		return &IGD{pppclients[0]}, nil
	}
	ipclients, _ := internetgateway1.NewWANIPConnection1ClientsByURL(loc)
	if len(ipclients) > 0 {
		return &IGD{ipclients[0]}, nil
	}
	return nil, errors.New("no UPnP-enabled gateway found at URL " + rawurl)
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

// Package upnp provides a simple and opinionated interface to UPnP-enabled

// routers, allowing users to forward ports and discover their external IP

// address. Specific quirks:

// - When attempting to discover UPnP-enabled routers on the network, only the

// first such router is returned. If you have multiple routers, this may cause

// some trouble. But why would you do that?

// - Forwarded ports are always symmetric, e.g. the router's port 9980 will be

// mapped to the client's port 9980. This will be unacceptable for some

// purposes, but too bad. Symmetric mappings are the desired behavior 99% of

// the time, and they save a function argument.

// - TCP and UDP protocols are forwarded together.

// - Ports are forwarded permanently. Some other implementations lease a port

// mapping for a set duration, and then renew it periodically. This is nice,

// because it means mappings won't stick around after they've served their

// purpose. Unfortunately, some routers only support permanent mappings, so this

// package has chosen to support the lowest common denominator. To un-forward a

// port, you must use the Clear function (or do it manually).

// Once you've discovered your router, you can retrieve its address by calling

// its Location method. This address can be supplied to Load to connect to the

// router directly, which is much faster than calling Discover.

package upnp

import (

"context"

"errors"

"net/url"

"time"

"gitlab.com/NebulousLabs/fastrand"

"github.com/huin/goupnp"

"github.com/huin/goupnp/dcps/internetgateway1"

)

// An IGD provides an interface to the most commonly used functions of an

// Internet Gateway Device: discovering the external IP, and forwarding ports.

type IGD struct {

// This interface is satisfied by the internetgateway1.WANIPConnection1

// and internetgateway1.WANPPPConnection1 types.

client interface {

GetExternalIPAddress() (string, error)

AddPortMapping(string, uint16, string, uint16, string, bool, string, uint32) error

GetSpecificPortMappingEntry(string, uint16, string) (uint16, string, bool, string, uint32, error)

DeletePortMapping(string, uint16, string) error

GetServiceClient() *goupnp.ServiceClient

}

// ExternalIP returns the router's external IP.

func (d *IGD) ExternalIP() (string, error) {

return d.client.GetExternalIPAddress()

}

// Forward forwards the specified protcol, port, and adds its description to the

// router's port mapping table.

func (d *IGD) Forward(routerPort uint16, protcol string, destIP string, destPort uint16, desc string) error {

time.Sleep(time.Millisecond)

return d.client.AddPortMapping("", routerPort, protcol, destPort, destIP, true, desc, 0)

}

// Clear un-forwards a port, removing it from the router's port mapping table.

func (d *IGD) Clear(port uint16, protcol string) error {

time.Sleep(time.Millisecond)

return d.client.DeletePortMapping("", port, protcol)

}

// Discover is deprecated; use DiscoverCtx instead.

func Discover() (*IGD, error) {

return DiscoverCtx(context.Background())

}

// DiscoverCtx scans the local network for routers and returns the first

// UPnP-enabled router it encounters. It will try up to 3 times to find a

// router, sleeping a random duration between each attempt. This is to

// mitigate a race condition with many callers attempting to discover

// simultaneously.

func DiscoverCtx(ctx context.Context) (*IGD, error) {

// TODO: if more than one client is found, only return those on the same

// subnet as the user?

maxTries := 3

sleepTime := time.Millisecond * time.Duration(fastrand.Intn(5000))

for try := 0; try < maxTries; try++ {

pppclients, _, _ := internetgateway1.NewWANPPPConnection1Clients()

if len(pppclients) > 0 {

return &IGD{pppclients[0]}, nil

}

ipclients, _, _ := internetgateway1.NewWANIPConnection1Clients()

if len(ipclients) > 0 {

return &IGD{ipclients[0]}, nil

}

select {

case <-ctx.Done():

return nil, context.Canceled

case <-time.After(sleepTime):

}

sleepTime *= 2

}

return nil, errors.New("no UPnP-enabled gateway found")

}

// Load connects to the router service specified by rawurl. This is much

// faster than Discover. Generally, Load should only be called with values

// returned by the IGD's Location method.

func Load(rawurl string) (*IGD, error) {

loc, err := url.Parse(rawurl)

if err != nil {

return nil, err

}

pppclients, _ := internetgateway1.NewWANPPPConnection1ClientsByURL(loc)

if len(pppclients) > 0 {

return &IGD{pppclients[0]}, nil

}

ipclients, _ := internetgateway1.NewWANIPConnection1ClientsByURL(loc)

if len(ipclients) > 0 {

return &IGD{ipclients[0]}, nil

}

return nil, errors.New("no UPnP-enabled gateway found at URL " + rawurl)

}

main.go:

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strings"

	"go-upnp-simple/upnp"
)

func main() {
	localIPv4 := "192.168.1.14"
	var internalPort uint16 = 80
	var externalPort uint16 = 8080
	desc := "go upnp test"

	// UPnPデバイスの検索
	igo, err := upnp.Discover()
	if err != nil {
		log.Println(err)
		return
	}

	// ルーターの外部IPアドレスを取得
	externalIP, err := igo.ExternalIP()
	if err != nil {
		log.Println(err)
		return
	}

	// ポートマッピングを追加 TCP
	err = igo.Forward(externalPort, "TCP", localIPv4, internalPort, desc)
	if err != nil {
		log.Println("error forwarding port", err)
		return
	}
	// ポートマッピングを追加 UDP
	err = igo.Forward(externalPort, "UDP", localIPv4, internalPort, desc)
	if err != nil {
		log.Println("error forwarding port", err)
		return
	}

	log.Printf("From external %s:%d forwarded to local %s:%d\n", externalIP, externalPort, localIPv4, internalPort)

	stringPrompt("Press enter key to exit...")

	// ポートマッピングを削除 TCP
	err = igo.Clear(externalPort, "TCP")
	if err != nil {
		log.Println(err)
	}
	// ポートマッピングを削除 UDP
	err = igo.Clear(externalPort, "UDP")
	if err != nil {
		log.Println(err)
	}
}

// stringPrompt asks for a string value using the label
// https://dev.to/tidalcloud/interactive-cli-prompts-in-go-3bj9
func stringPrompt(label string) string {
	var s string
	r := bufio.NewReader(os.Stdin)
	for {
		fmt.Fprint(os.Stderr, label+" ")
		s, _ = r.ReadString('\n')
		if s != "" {
			break
		}
	}
	return strings.TrimSpace(s)
}

package main

import (

"bufio"

"fmt"

"log"

"os"

"strings"

"go-upnp-simple/upnp"

)

func main() {

localIPv4 := "192.168.1.14"

var internalPort uint16 = 80

var externalPort uint16 = 8080

desc := "go upnp test"

// UPnPデバイスの検索

igo, err := upnp.Discover()

if err != nil {

log.Println(err)

return

}

// ルーターの外部IPアドレスを取得

externalIP, err := igo.ExternalIP()

if err != nil {

log.Println(err)

return

}

// ポートマッピングを追加 TCP

err = igo.Forward(externalPort, "TCP", localIPv4, internalPort, desc)

if err != nil {

log.Println("error forwarding port", err)

return

}

// ポートマッピングを追加 UDP

err = igo.Forward(externalPort, "UDP", localIPv4, internalPort, desc)

if err != nil {

log.Println("error forwarding port", err)

return

}

log.Printf("From external %s:%d forwarded to local %s:%d\n", externalIP, externalPort, localIPv4, internalPort)

stringPrompt("Press enter key to exit...")

// ポートマッピングを削除 TCP

err = igo.Clear(externalPort, "TCP")

if err != nil {

log.Println(err)

}

// ポートマッピングを削除 UDP

err = igo.Clear(externalPort, "UDP")

if err != nil {

log.Println(err)

}

// stringPrompt asks for a string value using the label

// https://dev.to/tidalcloud/interactive-cli-prompts-in-go-3bj9

func stringPrompt(label string) string {

var s string

r := bufio.NewReader(os.Stdin)

for {

fmt.Fprint(os.Stderr, label+" ")

s, _ = r.ReadString('\n')

if s != "" {

break

}

return strings.TrimSpace(s)

}

2022年12月6日2022年12月6日

golang でログ出力を止める / stop logging in golang

package main

import (
    "log"
)

func init() {
    log.SetOutput(io.Discard)
}

...

package main

import (

"log"

)

func init() {

log.SetOutput(io.Discard)

}

...

filepath and path packages

path の操作ではまった。
path の操作には2つのパッケージが使用できるですが
filepath と path
path の方知りませんでした

パスの区切り文字が違う
filepath パッケージは OS固有のものが使用され
path パッケージは “/” が使用されるとのことで

当たり前ですが、
embed パッケージで使用する path は区切りが常に “/”

—

2022年8月10日2022年8月11日

vscode に golang の build tag 指定方法 / How to specify golang build tag for vscode

“staticcheck” に替わってから？ vscode で golang開発する際に
下記のように build tag でソースコードの置き換えをしていると

//go:build foo_bar

1	//go:build foo_bar

この build tag を書いたファイルで vscode の機能が上手く働いてくれない場合がありました。チェックが厳密？正確？になったから？でしょうか。

環境変数指定で解決しました。複数指定はカンマ区切りでした…
と言うことで開発の際には環境変数をちゃんと指定しとけよってことでした。

$ export GOFLAGS="-tags=debug,foo_bar,ja_JP"

1	$ export GOFLAGS="-tags=debug,foo_bar,ja_JP"

vscode の設定で何とかするには、Goの公式拡張機能を入れて
プロジェクト内に “.vscode/settings.json” を作成してこんな感じです。

{
    "go.toolsEnvVars": {
        "GOFLAGS": "-tags=debug,foo_bar,ja_JP"
    }
}

{

"go.toolsEnvVars": {

"GOFLAGS": "-tags=debug,foo_bar,ja_JP"

}

Environment variables that will be passed to the tools that run the Go tools (e.g. CGO_CFLAGS) and debuggee process launched by Delve. Format as string key:value pairs. When debugging, merged with envFile and env values with precedence env > envFile > go.toolsEnvVars.

説明に書かれている「環境ファイル」はおそらく “~/.config/go/env”

vscode の EXPLORERバーの下の方の GOセクション？の env で編集できるようです。

2022年7月20日2022年7月20日

電子帳簿保存法なにやらで pdf ファイルが増えて何のファイルか分からなくなるので取り敢えず、自動でファイル名を変更してみるテスト / Rename the pdf receipt using pdftotext and golang

// 電子帳簿保存法なにやらで pdf ファイルが増えて
// 何のファイルか分からなくなるので
// 取り敢えず、自動でファイル名を変更してみる
//
// pdftotext を利用して pdf からテキストを取り出しそれを利用してファイル名を変更する
// 今回は以下のファイルを対象にしている
// 変更前: foo{数字}.pdf
// 変更後: foo_{受付時刻}_{受付時刻}_{振込指定日}_{受取人}_{信用金庫名}_{支店名}.pdf

package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"

	"github.com/dlclark/regexp2"
)

type Name struct {
	bank      string
	branch    string
	reception string
	specified string
	receiver  string
}

func main() {
	for i := 1; i < len(os.Args); i++ {
		arg := os.Args[i]
		dir := filepath.Dir(arg)
		basename := filepath.Base(arg)
		ext := filepath.Ext(arg)
		// fname := basename[0 : len(basename)-len(ext)]
		if strings.ToLower(ext) != ".pdf" {
			continue
		}

		if strings.Index(strings.ToLower(basename), "foo") != -1 {
			text, err := pdftotext(arg)
			if err != nil {
				fmt.Println(err)
				continue
			}
			// fmt.Println(i, dir, fname, ext, text)
			// fmt.Println("=====================")
			name := foo(text)
			newName := filepath.Join(dir, fmt.Sprintf("foo_%s_%s_%s_%s_%s%s", name.reception, name.specified, name.receiver, name.bank, name.branch, ext))
			if Exists(newName) {
				continue
			}
			fmt.Println(arg, "==>", newName)
			if err = os.Rename(arg, newName); err != nil {
				fmt.Println(err)
			}
		}
	}
}

func pdftotext(pdf string) (text string, err error) {
	var out []byte
	out, err = exec.Command("pdftotext", pdf, "-").Output()
	if err != nil {
		return
	}
	text = string(out)
	return
}

func foo(text string) (name Name) {

	// Bank
	// re := regexp2.MustCompile(`(?m)^.*信用金庫`, 0)
	re := regexp2.MustCompile(`.*信用金庫`, 0)
	m, _ := re.FindStringMatch(text)
	bank := strings.TrimSpace(m.String())

	// Branch
	re = regexp2.MustCompile(`お取引店[\s\n]+(.*)`, 0)
	m, _ = re.FindStringMatch(text)
	gps := m.Groups()
	branch := strings.TrimSpace(gps[1].Captures[0].String())

	// Reception datetime
	re = regexp2.MustCompile(`受付時刻[\s\n]+(\d+)年(\d+)月(\d+)日(\d+)時(\d+)分(\d+)秒`, 0)
	m, _ = re.FindStringMatch(text)
	gps = m.Groups()
	reception := fmt.Sprintf("%04d-%02d-%02d_%02d%02d%02d",
		atoi(gps[1].Captures[0].String()),
		atoi(gps[2].Captures[0].String()),
		atoi(gps[3].Captures[0].String()),
		atoi(gps[4].Captures[0].String()),
		atoi(gps[5].Captures[0].String()),
		atoi(gps[6].Captures[0].String()))

	// Specified transfer date
	re = regexp2.MustCompile(`振込指定日[\s\n]+(\d+)年(\d+)月(\d+)日`, 0)
	m, _ = re.FindStringMatch(text)
	gps = m.Groups()
	specified := fmt.Sprintf("%04d-%02d-%02d",
		atoi(gps[1].Captures[0].String()),
		atoi(gps[2].Captures[0].String()),
		atoi(gps[3].Captures[0].String()))

	// Receiver
	re = regexp2.MustCompile(`受取人[\s\n]+(.*)`, 0)
	m, _ = re.FindStringMatch(text)
	gps = m.Groups()
	receiver := strings.TrimSpace(gps[1].Captures[0].String())

	/*
		for i := 0; i < len(gps); i++ {
			for j := 0; j < len(gps[i].Captures); j++ {
				fmt.Println(i, j, gps[i].Captures[j].String())
			}
		}
	*/

	// fmt.Println("bank", bank, "branch", branch, "reception", reception, "specified", specified, "receiver", receiver)

	return Name{
		bank:      bank,
		branch:    branch,
		reception: reception,
		specified: specified,
		receiver:  receiver,
	}
}

func Exists(filename string) bool {
	_, err := os.Stat(filename)
	return err == nil
}

func atoi(a string) int {
	i, err := strconv.Atoi(a)
	if err != nil {
		panic(err)
	}
	return i
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

// 電子帳簿保存法なにやらで pdf ファイルが増えて

// 何のファイルか分からなくなるので

// 取り敢えず、自動でファイル名を変更してみる

// pdftotext を利用して pdf からテキストを取り出しそれを利用してファイル名を変更する

// 今回は以下のファイルを対象にしている

// 変更前: foo{数字}.pdf

// 変更後: foo_{受付時刻}_{受付時刻}_{振込指定日}_{受取人}_{信用金庫名}_{支店名}.pdf

package main

import (

"fmt"

"os"

"os/exec"

"path/filepath"

"strconv"

"strings"

"github.com/dlclark/regexp2"

)

type Name struct {

bank string

branch string

reception string

specified string

receiver string

}

func main() {

for i := 1; i < len(os.Args); i++ {

arg := os.Args[i]

dir := filepath.Dir(arg)

basename := filepath.Base(arg)

ext := filepath.Ext(arg)

// fname := basename[0 : len(basename)-len(ext)]

if strings.ToLower(ext) != ".pdf" {

continue

}

if strings.Index(strings.ToLower(basename), "foo") != -1 {

text, err := pdftotext(arg)

if err != nil {

fmt.Println(err)

continue

}

// fmt.Println(i, dir, fname, ext, text)

// fmt.Println("=====================")

name := foo(text)

newName := filepath.Join(dir, fmt.Sprintf("foo_%s_%s_%s_%s_%s%s", name.reception, name.specified, name.receiver, name.bank, name.branch, ext))

if Exists(newName) {

continue

}

fmt.Println(arg, "==>", newName)

if err = os.Rename(arg, newName); err != nil {

fmt.Println(err)

}

func pdftotext(pdf string) (text string, err error) {

var out []byte

out, err = exec.Command("pdftotext", pdf, "-").Output()

if err != nil {

return

}

text = string(out)

return

}

func foo(text string) (name Name) {

// Bank

// re := regexp2.MustCompile(`(?m)^.*信用金庫`, 0)

re := regexp2.MustCompile(`.*信用金庫`, 0)

m, _ := re.FindStringMatch(text)

bank := strings.TrimSpace(m.String())

// Branch

re = regexp2.MustCompile(`お取引店[\s\n]+(.*)`, 0)

m, _ = re.FindStringMatch(text)

gps := m.Groups()

branch := strings.TrimSpace(gps[1].Captures[0].String())

// Reception datetime

re = regexp2.MustCompile(`受付時刻[\s\n]+(\d+)年(\d+)月(\d+)日(\d+)時(\d+)分(\d+)秒`, 0)

m, _ = re.FindStringMatch(text)

gps = m.Groups()

reception := fmt.Sprintf("%04d-%02d-%02d_%02d%02d%02d",

atoi(gps[1].Captures[0].String()),

atoi(gps[2].Captures[0].String()),

atoi(gps[3].Captures[0].String()),

atoi(gps[4].Captures[0].String()),

atoi(gps[5].Captures[0].String()),

atoi(gps[6].Captures[0].String()))

// Specified transfer date

re = regexp2.MustCompile(`振込指定日[\s\n]+(\d+)年(\d+)月(\d+)日`, 0)

m, _ = re.FindStringMatch(text)

gps = m.Groups()

specified := fmt.Sprintf("%04d-%02d-%02d",

atoi(gps[1].Captures[0].String()),

atoi(gps[2].Captures[0].String()),

atoi(gps[3].Captures[0].String()))

// Receiver

re = regexp2.MustCompile(`受取人[\s\n]+(.*)`, 0)

m, _ = re.FindStringMatch(text)

gps = m.Groups()

receiver := strings.TrimSpace(gps[1].Captures[0].String())

for i := 0; i < len(gps); i++ {

for j := 0; j < len(gps[i].Captures); j++ {

fmt.Println(i, j, gps[i].Captures[j].String())

}

// fmt.Println("bank", bank, "branch", branch, "reception", reception, "specified", specified, "receiver", receiver)

return Name{

bank: bank,

branch: branch,

reception: reception,

specified: specified,

receiver: receiver,

}

func Exists(filename string) bool {

_, err := os.Stat(filename)

return err == nil

}

func atoi(a string) int {

i, err := strconv.Atoi(a)

if err != nil {

panic(err)

}

return i

}

2022年6月30日2022年7月7日

Convert JSON with comments to JSON with Golang

コメント付きの JSON (JSONC) を JSON にコンバート
JSON ファイルってコメント付けておかないとすぐになんだか分からなくなるのです。

“github.com/tidwall/jsonc” を使いました。

/*
Name     : jsonctojson
Modified : 2022-06-30

$ go build -ldflags "-s -w" -trimpath .
*/

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"

	"github.com/fsnotify/fsnotify"
	"github.com/tidwall/jsonc"
)

func readAll(filename string) (b []byte, err error) {
	file, err := os.Open(filename)
	if err != nil {
		return
	}
	defer file.Close()

	return ioutil.ReadAll(file)
}

func backup(srcPath, dstPath string) error {
	src, err := os.Open(srcPath)
	if err != nil {
		return err
	}
	defer src.Close()

	dst, err := os.Create(dstPath)
	if err != nil {
		return err
	}
	defer dst.Close()

	_, err = io.Copy(dst, src)
	return err
}

func convert(srcJsonc string) error {
	ext := filepath.Ext(srcJsonc)
	if strings.Compare(strings.ToLower(ext), ".jsonc") != 0 {
		puterr(fmt.Sprintf("not .jsonc: %s", srcJsonc))
		return fmt.Errorf("not .jsonc")
	}
	dir := filepath.Dir(srcJsonc)
	base := filepath.Base(srcJsonc)

	outJson := filepath.Join(dir, base[:len(base)-len(ext)]) + ".json"
	bakJson := filepath.Join(dir, base[:len(base)-len(ext)]) + ".bak"

	state, err := os.Stat(srcJsonc)
	if err != nil {
		puterr(fmt.Sprintf("%s: %s", err, srcJsonc))
		return err
	}

	b, err := readAll(srcJsonc)
	if err != nil {
		puterr(fmt.Sprintf("%s: %s", err, srcJsonc))
		return err
	}

	b = jsonc.ToJSON(b)

	var jsonAny interface{}
	if err = json.Unmarshal(b, &jsonAny); err != nil {
		puterr(fmt.Sprintf("%s: %s", err, srcJsonc))
		return err
	}

	var formatedJSON bytes.Buffer
	if err = json.Indent(&formatedJSON, b, "", "    "); err != nil { // indent
		puterr(fmt.Sprintf("%s: %s", err, srcJsonc))
		return err
	}

	if err = backup(srcJsonc, bakJson); err != nil {
		puterr(fmt.Sprintf("%s: %s", err, srcJsonc))
		return err
	}

	if err = ioutil.WriteFile(outJson, formatedJSON.Bytes(), state.Mode()); err != nil {
		puterr(fmt.Sprintf("%s: %s", err, srcJsonc))
		return err
	}

	fmt.Println(formatedJSON.String())
	puterr(fmt.Sprintf("%s ==> %s, backup: %s", srcJsonc, outJson, bakJson))

	return err
}

func puterr(s string) {
	fmt.Fprintf(os.Stderr, "%s[%s] %s\n", exeName, time.Now().Format("2006-01-02 15:04:05"), s)
}

func watch(wg *sync.WaitGroup) (watcher *fsnotify.Watcher, err error) {
	if watcher, err = fsnotify.NewWatcher(); err != nil {
		return
	}

	go func() {
		defer watcher.Close()
		wg.Add(1)

		for {
			select {
			case event, ok := <-watcher.Events:
				if !ok {
					break
				}

				state, err := os.Stat(event.Name)
				if err != nil {
					puterr(fmt.Sprintf("%s", err))
					continue
				}
				if state.IsDir() {
					if event.Op&fsnotify.Create == fsnotify.Create {
						watcher.Add(event.Name)
					} else if event.Op&fsnotify.Remove == fsnotify.Remove {
						watcher.Remove(event.Name)
					} else if event.Op&fsnotify.Rename == fsnotify.Rename {
						watcher.Add(event.Name)        // to
						watcher.Remove(event.String()) // from
					}
				} else {
					if event.Op&fsnotify.Write == fsnotify.Write {
						convert(event.Name)
					}
				}

			case err, ok := <-watcher.Errors:
				if !ok {
					break
				}
				puterr(fmt.Sprintf("%s", err))
			}
		} // for

		wg.Done()
	}()

	return
}

var exeName string

func main() {
	exeName = filepath.Base(os.Args[0])
	wg := &sync.WaitGroup{}

	var (
		flagWatcher bool
	)
	flag.BoolVar(&flagWatcher, "watch", false, "watching file or directory")
	Usage := func() {
		fmt.Fprintf(os.Stderr, "Usage: %s [options] <file|directory...>\n", exeName)
		flag.PrintDefaults()
	}

	flag.Parse()
	args := flag.Args()
	if len(args) == 0 {
		Usage()
		os.Exit(1)
	}

	var err error
	var w *fsnotify.Watcher
	if flagWatcher {
		w, err = watch(wg)
		if err != nil {
			puterr(fmt.Sprintf("%s", err))
			os.Exit(1)
		}
	}

	for _, path := range args {
		puterr(fmt.Sprintf("%s", path))

		state, err := os.Stat(path)
		if err != nil {
			puterr(fmt.Sprintf("%s", err))
			continue
		}
		if !state.IsDir() {
			convert(path)

			if flagWatcher {
				if err := w.Add(path); err != nil {
					puterr(fmt.Sprintf("%s", err))
					// os.Exit(1)
				}
			}

			continue
		}

		if err = filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				puterr(fmt.Sprintf("%s", err))
				// os.Exit(1)
			}

			if info.IsDir() {
				if flagWatcher {
					if err := w.Add(path); err != nil {
						puterr(fmt.Sprintf("%s", err))
						// os.Exit(1)
					}
				}
				return nil
			}

			convert(path)

			return nil
		}); err != nil {
			puterr(fmt.Sprintf("%s", err))
			os.Exit(1)
		}
	}

	wg.Wait()
	os.Exit(0)
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

Name : jsonctojson

Modified : 2022-06-30

$ go build -ldflags "-s -w" -trimpath .

package main

import (

"bytes"

"encoding/json"

"flag"

"fmt"

"io"

"io/ioutil"

"os"

"path/filepath"

"strings"

"sync"

"time"

"github.com/fsnotify/fsnotify"

"github.com/tidwall/jsonc"

)

func readAll(filename string) (b []byte, err error) {

file, err := os.Open(filename)

if err != nil {

return

}

defer file.Close()

return ioutil.ReadAll(file)

}

func backup(srcPath, dstPath string) error {

src, err := os.Open(srcPath)

if err != nil {

return err

}

defer src.Close()

dst, err := os.Create(dstPath)

if err != nil {

return err

}

defer dst.Close()

_, err = io.Copy(dst, src)

return err

}

func convert(srcJsonc string) error {

ext := filepath.Ext(srcJsonc)

if strings.Compare(strings.ToLower(ext), ".jsonc") != 0 {

puterr(fmt.Sprintf("not .jsonc: %s", srcJsonc))

return fmt.Errorf("not .jsonc")

}

dir := filepath.Dir(srcJsonc)

base := filepath.Base(srcJsonc)

outJson := filepath.Join(dir, base[:len(base)-len(ext)]) + ".json"

bakJson := filepath.Join(dir, base[:len(base)-len(ext)]) + ".bak"

state, err := os.Stat(srcJsonc)

if err != nil {

puterr(fmt.Sprintf("%s: %s", err, srcJsonc))

return err

}

b, err := readAll(srcJsonc)

if err != nil {

puterr(fmt.Sprintf("%s: %s", err, srcJsonc))

return err

}

b = jsonc.ToJSON(b)

var jsonAny interface{}

if err = json.Unmarshal(b, &jsonAny); err != nil {

puterr(fmt.Sprintf("%s: %s", err, srcJsonc))

return err

}

var formatedJSON bytes.Buffer

if err = json.Indent(&formatedJSON, b, "", " "); err != nil { // indent

puterr(fmt.Sprintf("%s: %s", err, srcJsonc))

return err

}

if err = backup(srcJsonc, bakJson); err != nil {

puterr(fmt.Sprintf("%s: %s", err, srcJsonc))

return err

}

if err = ioutil.WriteFile(outJson, formatedJSON.Bytes(), state.Mode()); err != nil {

puterr(fmt.Sprintf("%s: %s", err, srcJsonc))

return err

}

fmt.Println(formatedJSON.String())

puterr(fmt.Sprintf("%s ==> %s, backup: %s", srcJsonc, outJson, bakJson))

return err

}

func puterr(s string) {

fmt.Fprintf(os.Stderr, "%s[%s] %s\n", exeName, time.Now().Format("2006-01-02 15:04:05"), s)

}

func watch(wg *sync.WaitGroup) (watcher *fsnotify.Watcher, err error) {

if watcher, err = fsnotify.NewWatcher(); err != nil {

return

}

go func() {

defer watcher.Close()

wg.Add(1)

for {

select {

case event, ok := <-watcher.Events:

if !ok {

break

}

state, err := os.Stat(event.Name)

if err != nil {

puterr(fmt.Sprintf("%s", err))

continue

}

if state.IsDir() {

if event.Op&fsnotify.Create == fsnotify.Create {

watcher.Add(event.Name)

} else if event.Op&fsnotify.Remove == fsnotify.Remove {

watcher.Remove(event.Name)

} else if event.Op&fsnotify.Rename == fsnotify.Rename {

watcher.Add(event.Name) // to

watcher.Remove(event.String()) // from

}

} else {

if event.Op&fsnotify.Write == fsnotify.Write {

convert(event.Name)

}

case err, ok := <-watcher.Errors:

if !ok {

break

}

puterr(fmt.Sprintf("%s", err))

}

} // for

wg.Done()

}()

return

}

var exeName string

func main() {

exeName = filepath.Base(os.Args[0])

wg := &sync.WaitGroup{}

var (

flagWatcher bool

)

flag.BoolVar(&flagWatcher, "watch", false, "watching file or directory")

Usage := func() {

fmt.Fprintf(os.Stderr, "Usage: %s [options] <file|directory...>\n", exeName)

flag.PrintDefaults()

}

flag.Parse()

args := flag.Args()

if len(args) == 0 {

Usage()

os.Exit(1)

}

var err error

var w *fsnotify.Watcher

if flagWatcher {

w, err = watch(wg)

if err != nil {

puterr(fmt.Sprintf("%s", err))

os.Exit(1)

}

for _, path := range args {

puterr(fmt.Sprintf("%s", path))

state, err := os.Stat(path)

if err != nil {

puterr(fmt.Sprintf("%s", err))

continue

}

if !state.IsDir() {

convert(path)

if flagWatcher {

if err := w.Add(path); err != nil {

puterr(fmt.Sprintf("%s", err))

// os.Exit(1)

}

continue

}

if err = filepath.Walk(path, func(path string, info os.FileInfo, err error) error {

if err != nil {

puterr(fmt.Sprintf("%s", err))

// os.Exit(1)

}

if info.IsDir() {

if flagWatcher {

if err := w.Add(path); err != nil {

puterr(fmt.Sprintf("%s", err))

// os.Exit(1)

}

return nil

}

convert(path)

return nil

}); err != nil {

puterr(fmt.Sprintf("%s", err))

os.Exit(1)

}

wg.Wait()

os.Exit(0)

}

—