okamura – ページ 29 – テックメモ

2018-10-042020-05-06

golang クロージャ

package main

import (
	"log"
)

/*
無名関数が定義された環境(スコープ)の変数が保存される
*/

func main() {
	f := out()
	f()//11
	f()//12
}

func out() func() {

	i := 10
	return func() {
		i++
		log.Print(i)
	}
}

package main

import (

"log"

)

無名関数が定義された環境(スコープ)の変数が保存される

func main() {

f := out()

f()//11

f()//12

}

func out() func() {

i := 10

return func() {

i++

log.Print(i)

}

2018-10-032020-05-06

golang sshでdbのバックアップ

サーバーにあるwordpressのDBをバックアップしようと思い、sshを調べた。
ファイルの転送に手軽な方法がなかったため標準出力をファイルへ書き出すことに。

package main

import (
	"io/ioutil"
	"log"
	"os"

	"golang.org/x/crypto/ssh"
)

func main() {

	host := ""
	port := ""
	user := ""

	backupQuery := "mysqldumpする"
	downloadQuery := "catする"

	buf, err := ioutil.ReadFile("id_rsa.pem") //openssl rsa -in ~/.ssh/id_rsa -outform pem > id_rsa.pem
	if err != nil {
		log.Print(err)
		return
	}
	key, err := ssh.ParsePrivateKey(buf)
	if err != nil {
		log.Print(err)
		return
	}

	config := &ssh.ClientConfig{
		User: user,
		Auth: []ssh.AuthMethod{
			ssh.PublicKeys(key),
		},
		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
	}

	conn, err := ssh.Dial("tcp", host+":"+port, config)
	if err != nil {
		log.Print(err)
		return
	}
	defer conn.Close()

	backupSession, err := conn.NewSession()
	if err != nil {
		log.Print(err)
		return
	}
	remoteCmd(backupQuery, backupSession)

	downloadSession, err := conn.NewSession()
	if err != nil {
		log.Print(err)
		return
	}
	remoteCmd(downloadQuery, downloadSession)

	log.Print("done")
}

func remoteCmd(query string, session *ssh.Session) {

	defer session.Close()

	//リモートの標準出力をローカルの標準出力へ
	//session.Stdout = os.Stdout

	f, _ := os.Create("test.sql")
	session.Stdout = f
	session.Stderr = os.Stderr

	/*
		RunはWait付き。StartはWait無し
		出力はsessionのStdio,Stderr
		sessionに付きコマンドは1度
	*/

	if err := session.Run(query); err != nil {
		log.Print(err)
		return
	}

}

package main

import (

"io/ioutil"

"log"

"os"

"golang.org/x/crypto/ssh"

)

func main() {

host := ""

port := ""

user := ""

backupQuery := "mysqldumpする"

downloadQuery := "catする"

buf, err := ioutil.ReadFile("id_rsa.pem") //openssl rsa -in ~/.ssh/id_rsa -outform pem > id_rsa.pem

if err != nil {

log.Print(err)

return

}

key, err := ssh.ParsePrivateKey(buf)

if err != nil {

log.Print(err)

return

}

config := &ssh.ClientConfig{

User: user,

Auth: []ssh.AuthMethod{

ssh.PublicKeys(key),

HostKeyCallback: ssh.InsecureIgnoreHostKey(),

}

conn, err := ssh.Dial("tcp", host+":"+port, config)

if err != nil {

log.Print(err)

return

}

defer conn.Close()

backupSession, err := conn.NewSession()

if err != nil {

log.Print(err)

return

}

remoteCmd(backupQuery, backupSession)

downloadSession, err := conn.NewSession()

if err != nil {

log.Print(err)

return

}

remoteCmd(downloadQuery, downloadSession)

log.Print("done")

}

func remoteCmd(query string, session *ssh.Session) {

defer session.Close()

//リモートの標準出力をローカルの標準出力へ

//session.Stdout = os.Stdout

f, _ := os.Create("test.sql")

session.Stdout = f

session.Stderr = os.Stderr

RunはWait付き。StartはWait無し

出力はsessionのStdio,Stderr

sessionに付きコマンドは1度

if err := session.Run(query); err != nil {

log.Print(err)

return

}

2018-10-022020-05-06

golang色々

静的ファイル配信。jsonパース

package main

import (
	"encoding/json"

	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path/filepath"
)

func main() {

	//静的ファイル配信

	//http.Dirはhttp://foo:bar/のようなクエリのないURLがローカルのどのパス(root)となるかという意味
	//http://foo:bar/aaaのような指定の場合/aaaもローカルパスに必要となる。

	currentPath, _ := os.Executable()
	localRoot := filepath.Dir(currentPath)
	remoteRoot := http.Dir(localRoot)

	http.Handle("/", http.FileServer(remoteRoot))

	//パスを変更する場合
	//http.Handle("/html/", http.StripPrefix("/html/", http.FileServer(remoteRoot)))

	//リクエスト処理

	http.HandleFunc("/read", read)

	if err := http.ListenAndServe(":9000", nil); err != nil {
		log.Fatal(err)
	}
}

var dt interface{}

/*

type DataFormat struct {
	RequestID string
}

のように構造体を宣言し、インスタンスでjson.Unmarshalを受ける。

dt := DataFormat{}

*/

func read(w http.ResponseWriter, r *http.Request) {

	if r.Method != http.MethodPost {
		w.WriteHeader(http.StatusServiceUnavailable)
		return
	}

	/*

		json.Unmarshal(data []byte, v interface{}) error
		でjsonを受け取る

		io.Readerから[]byteに変換

		ioutil.ReadAll(io.Reader) ([]bytes, error)
		bytes.Buffer.ReadFrom(io.Reader) (int64, error)
		io.Copy(io.Writer, io.Reader) (int64, error)

	*/

	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		w.WriteHeader(http.StatusServiceUnavailable)
		log.Print(err)
		return
	}

	if err := json.Unmarshal(body, &dt); err != nil {
		w.WriteHeader(http.StatusServiceUnavailable)
		log.Print(err)
		return
	}

	//dtはinterface型で実際はmap型

	/*

		jsonがネストしていない場合アサーションのみで取り出せる。

		d := dt.(map[string]interface{})
		log.Print(d["main"])
		log.Print(reflect.TypeOf(d)) -> map[string]interface {}

		全体が配列のjsonなら以下のように取り出せる
		配列は[]interface{}のrangeで処理

		for _, aa := range dt.([]interface{}) {
			for cc, bb := range aa.(map[string]interface{}) {
				log.Print(cc)
				log.Print(bb)
			}
		}

		中で配列ネストされているような場合

		for k, v := range dt.(map[string]interface{}) {

			log.Print("1:", k) //jsonのkeyが入る
			log.Print("2:", v) //jsonのvalueが入る

			//vとvvは同じ値で型のtypeOfが入るのではない
			switch vv := v.(type) {
			case []interface{}:
				for _, y := range vv {
					yy := y.(map[string]interface{})
					log.Print("3:", yy["ID"])
					log.Print("4:", yy["名称"])
				}
			default:
				log.Print("5:", v)
			}
		}

	*/

	w.Header().Set("content-type", "application/json;charset=UTF-8")
	w.WriteHeader(http.StatusOK)

	if err := json.NewEncoder(w).Encode(dt); err != nil {
		w.WriteHeader(http.StatusServiceUnavailable)
		log.Print(err)
		return
	}
}

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

package main

import (

"encoding/json"

"io/ioutil"

"log"

"net/http"

"os"

"path/filepath"

)

func main() {

//静的ファイル配信

//http.Dirはhttp://foo:bar/のようなクエリのないURLがローカルのどのパス(root)となるかという意味

//http://foo:bar/aaaのような指定の場合/aaaもローカルパスに必要となる。

currentPath, _ := os.Executable()

localRoot := filepath.Dir(currentPath)

remoteRoot := http.Dir(localRoot)

http.Handle("/", http.FileServer(remoteRoot))

//パスを変更する場合

//http.Handle("/html/", http.StripPrefix("/html/", http.FileServer(remoteRoot)))

//リクエスト処理

http.HandleFunc("/read", read)

if err := http.ListenAndServe(":9000", nil); err != nil {

log.Fatal(err)

}

var dt interface{}

type DataFormat struct {

RequestID string

}

のように構造体を宣言し、インスタンスでjson.Unmarshalを受ける。

dt := DataFormat{}

func read(w http.ResponseWriter, r *http.Request) {

if r.Method != http.MethodPost {

w.WriteHeader(http.StatusServiceUnavailable)

return

}

json.Unmarshal(data []byte, v interface{}) error

でjsonを受け取る

io.Readerから[]byteに変換

ioutil.ReadAll(io.Reader) ([]bytes, error)

bytes.Buffer.ReadFrom(io.Reader) (int64, error)

io.Copy(io.Writer, io.Reader) (int64, error)

body, err := ioutil.ReadAll(r.Body)

if err != nil {

w.WriteHeader(http.StatusServiceUnavailable)

log.Print(err)

return

}

if err := json.Unmarshal(body, &dt); err != nil {

w.WriteHeader(http.StatusServiceUnavailable)

log.Print(err)

return

}

//dtはinterface型で実際はmap型

jsonがネストしていない場合アサーションのみで取り出せる。

d := dt.(map[string]interface{})

log.Print(d["main"])

log.Print(reflect.TypeOf(d)) -> map[string]interface {}

全体が配列のjsonなら以下のように取り出せる

配列は[]interface{}のrangeで処理

for _, aa := range dt.([]interface{}) {

for cc, bb := range aa.(map[string]interface{}) {

log.Print(cc)

log.Print(bb)

}

中で配列ネストされているような場合

for k, v := range dt.(map[string]interface{}) {

log.Print("1:", k) //jsonのkeyが入る

log.Print("2:", v) //jsonのvalueが入る

//vとvvは同じ値で型のtypeOfが入るのではない

switch vv := v.(type) {

case []interface{}:

for _, y := range vv {

yy := y.(map[string]interface{})

log.Print("3:", yy["ID"])

log.Print("4:", yy["名称"])

}

default:

log.Print("5:", v)

}

w.Header().Set("content-type", "application/json;charset=UTF-8")

w.WriteHeader(http.StatusOK)

if err := json.NewEncoder(w).Encode(dt); err != nil {

w.WriteHeader(http.StatusServiceUnavailable)

log.Print(err)

return

}

2018-09-272020-05-15

golang+MongoDB+Vue.js 色々

サーバーをgolang+MongoDBでフロントをVue.js
基本的な処理を色々メモ。

package main

import (
	"encoding/json"
	"fmt"
	"html/template"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path/filepath"

	"gopkg.in/mgo.v2"
)

func JsonMongo1(w http.ResponseWriter, r *http.Request) {

	info := &mgo.DialInfo{
		Addrs:    []string{"localhost:27017"},
		Database: "name_store",
		Username: "shiro",
		Password: "123",
		Source:   "admin",
	}

	//通常
	//session, err := mgo.Dial("localhost:27017")

	//認証
	session, err := mgo.DialWithInfo(info)
	if err != nil {
		return
	}
	defer session.Close()
	c := session.DB("name_store").C("names")

	t := []T{}

	//1件取得

	//if err := c.Find(bson.M{"name": "taro"}).One(&t); != nil{
	//	log.Print(err)
	//}

	if err := c.Find(nil).All(&t); err != nil {
		log.Print(err)
	}

	w.Header().Set("content-type", "application/json;charset=UTF-8")
	w.WriteHeader(http.StatusOK)

	if err := json.NewEncoder(w).Encode(t); err != nil {
		return
	}

}

func TemplateHtml(w http.ResponseWriter, r *http.Request) {

	p, err := os.Executable()
	if err != nil {
		return
	}

	t := template.Must(template.ParseFiles(filepath.FromSlash(filepath.Dir(p) + "/index.html")))

	if err := t.Execute(w, nil); err != nil {
		return
	}

}

func TemplateText(w http.ResponseWriter, r *http.Request) {

	p, err := os.Executable()
	if err != nil {
		return
	}

	f, err := ioutil.ReadFile(filepath.FromSlash(filepath.Dir(p) + "/vue.html"))
	if err != nil {
		return
	}

	fmt.Fprint(w, string(f))

}

func FromPost(w http.ResponseWriter, r *http.Request) {

	info := &mgo.DialInfo{
		Addrs:    []string{"localhost:27017"},
		Database: "name_store",
		Username: "shiro",
		Password: "123",
		Source:   "admin",
	}

	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		log.Print(err)
	}

	t := []T{}
	if err := json.Unmarshal(body, &t); err != nil {
		log.Print(err)
	}

	//認証
	session, err := mgo.DialWithInfo(info)
	if err != nil {
		log.Print(err)
	}
	defer session.Close()
	c := session.DB("name_store").C("names")

	err = c.Insert(&t[0])
	if err != nil {
		log.Print(err)
	}

}

func main() {

	http.HandleFunc("/1", RequestParams)
	http.HandleFunc("/2", QueryKeyValue)
	http.HandleFunc("/3", ResponseJson)
	http.HandleFunc("/4", JsonMongo1)
	http.HandleFunc("/5", TemplateHtml)
	http.HandleFunc("/6", TemplateText)
	http.HandleFunc("/7", FromPost)

	if err := http.ListenAndServe(":9000", nil); err != nil {
		log.Fatal(err)
	}

}

func RequestParams(w http.ResponseWriter, r *http.Request) {

	if r.Method != http.MethodGet {
		return
	}

	fmt.Fprintf(w, "%s\n", r.URL.Host)
	fmt.Fprintf(w, "%s\n", r.URL.Path)
	fmt.Fprintf(w, "%s\n", r.URL.RawQuery)
}

func QueryKeyValue(w http.ResponseWriter, r *http.Request) {

	if r.Method != http.MethodGet {
		return
	}

	for key, value := range r.URL.Query() {
		fmt.Fprintf(w, "key: %s\n", key)
		for i, v := range value {
			fmt.Fprintf(w, "value[%d]: %s\n", i, v)
		}
	}
}

type T struct {
	ID   json.Number
	Name string
}

func ResponseJson(w http.ResponseWriter, r *http.Request) {

	t := T{
		ID:   "1",
		Name: "taro",
	}

	w.Header().Set("content-type", "application/json;charset=UTF-8")
	w.WriteHeader(http.StatusOK)

	if err := json.NewEncoder(w).Encode(t); err != nil {
		return
	}

}

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

package main

import (

"encoding/json"

"fmt"

"html/template"

"io/ioutil"

"log"

"net/http"

"os"

"path/filepath"

"gopkg.in/mgo.v2"

)

func JsonMongo1(w http.ResponseWriter, r *http.Request) {

info := &mgo.DialInfo{

Addrs: []string{"localhost:27017"},

Database: "name_store",

Username: "shiro",

Password: "123",

Source: "admin",

}

//通常

//session, err := mgo.Dial("localhost:27017")

//認証

session, err := mgo.DialWithInfo(info)

if err != nil {

return

}

defer session.Close()

c := session.DB("name_store").C("names")

t := []T{}

//1件取得

//if err := c.Find(bson.M{"name": "taro"}).One(&t); != nil{

// log.Print(err)

//}

if err := c.Find(nil).All(&t); err != nil {

log.Print(err)

}

w.Header().Set("content-type", "application/json;charset=UTF-8")

w.WriteHeader(http.StatusOK)

if err := json.NewEncoder(w).Encode(t); err != nil {

return

}

func TemplateHtml(w http.ResponseWriter, r *http.Request) {

p, err := os.Executable()

if err != nil {

return

}

t := template.Must(template.ParseFiles(filepath.FromSlash(filepath.Dir(p) + "/index.html")))

if err := t.Execute(w, nil); err != nil {

return

}

func TemplateText(w http.ResponseWriter, r *http.Request) {

p, err := os.Executable()

if err != nil {

return

}

f, err := ioutil.ReadFile(filepath.FromSlash(filepath.Dir(p) + "/vue.html"))

if err != nil {

return

}

fmt.Fprint(w, string(f))

}

func FromPost(w http.ResponseWriter, r *http.Request) {

info := &mgo.DialInfo{

Addrs: []string{"localhost:27017"},

Database: "name_store",

Username: "shiro",

Password: "123",

Source: "admin",

}

body, err := ioutil.ReadAll(r.Body)

if err != nil {

log.Print(err)

}

t := []T{}

if err := json.Unmarshal(body, &t); err != nil {

log.Print(err)

}

//認証

session, err := mgo.DialWithInfo(info)

if err != nil {

log.Print(err)

}

defer session.Close()

c := session.DB("name_store").C("names")

err = c.Insert(&t[0])

if err != nil {

log.Print(err)

}

func main() {

http.HandleFunc("/1", RequestParams)

http.HandleFunc("/2", QueryKeyValue)

http.HandleFunc("/3", ResponseJson)

http.HandleFunc("/4", JsonMongo1)

http.HandleFunc("/5", TemplateHtml)

http.HandleFunc("/6", TemplateText)

http.HandleFunc("/7", FromPost)

if err := http.ListenAndServe(":9000", nil); err != nil {

log.Fatal(err)

}

func RequestParams(w http.ResponseWriter, r *http.Request) {

if r.Method != http.MethodGet {

return

}

fmt.Fprintf(w, "%s\n", r.URL.Host)

fmt.Fprintf(w, "%s\n", r.URL.Path)

fmt.Fprintf(w, "%s\n", r.URL.RawQuery)

}

func QueryKeyValue(w http.ResponseWriter, r *http.Request) {

if r.Method != http.MethodGet {

return

}

for key, value := range r.URL.Query() {

fmt.Fprintf(w, "key: %s\n", key)

for i, v := range value {

fmt.Fprintf(w, "value[%d]: %s\n", i, v)

}

type T struct {

ID json.Number

Name string

}

func ResponseJson(w http.ResponseWriter, r *http.Request) {

t := T{

ID: "1",

Name: "taro",

}

w.Header().Set("content-type", "application/json;charset=UTF-8")

w.WriteHeader(http.StatusOK)

if err := json.NewEncoder(w).Encode(t); err != nil {

return

}

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8" />
    <title>title</title>
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
</head>
<body>

<div id="app">

<input type="button" v-on:click="fetchData" value="Get">
<input type="button" v-on:click="insertData" value="Up">

<br>

<table>
        <tr v-for="i in res" v-bind:id="i.ID">
            <td>{{ i.ID }}</td>
            <td>{{ i.Name }}</td>
        </tr>
</table>

<input type="text" v-bind:value="v">
<input type="range" max="1" min="0" step="0.25" v-model="v">



</div>

<script>

let vm = new Vue({
    el: '#app',
    data:{
        v: 0,
        res: [
            {"ID":1, "Name":"taro"},
            {"ID":2, "Name":"jiro"}
        ]
    },
    methods:{
        insertData(){
            console.log(vm.res);
            axios
            .post('http://localhost:9000/7',vm.res)
            .then(response => {
                console.log(response.status) 
            })
        },
        fetchData(){
            axios
            .get('http://localhost:9000/4')
            .then(response => {

                //forceUpdateでリアクティブになる
                //vm.res[1] = response.data;
                //vm.$forceUpdate();

                console.log(response.status) 

                //vm.resは配列

                //レスポンスのjsonが配列ではない場合の指定の方法
                //Vue.set(vm.res, 1, response.data);

                //配列の場合の指定の方法(vm.resが全て置き換わる)
                Vue.set(vm, 'res', response.data)
                
            })
        }
    } 
})

</script>
</body>
</html>

<!DOCTYPE html>

<html>

<head>

<title>title</title>

</head>

<body>

<br>

<table>

</tr>

</table>

</div>

let vm = new Vue({

el: '#app',

data:{

v: 0,

res: [

{"ID":1, "Name":"taro"},

{"ID":2, "Name":"jiro"}

]

methods:{

insertData(){

console.log(vm.res);

axios

.post('http://localhost:9000/7',vm.res)

.then(response => {

console.log(response.status)

})

fetchData(){

axios

.get('http://localhost:9000/4')

.then(response => {

//forceUpdateでリアクティブになる

//vm.res[1] = response.data;

//vm.$forceUpdate();

console.log(response.status)

//vm.resは配列

//レスポンスのjsonが配列ではない場合の指定の方法

//Vue.set(vm.res, 1, response.data);

//配列の場合の指定の方法(vm.resが全て置き換わる)

Vue.set(vm, 'res', response.data)

})

}

})

</script>

</body>

</html>

2018-09-252018-09-26

インストール

/etc/yum.repos.d/mongodb-org-4.0.repo

[mongodb-org-4.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.0.asc

を記載し、

yum install -y mongodb-org

起動
systemctl start mongod

停止
systemctl stop mongod

再起動
systemctl restart mongod

自動起動
systemctl enable mongod

シェル起動
mongo

シェル終了
exit

Mongoシェルコマンド

db切り替え(作成)
use DB

db削除
db.dropDatabase()

利用中db
db

db一覧
show dbs

コレクション一覧
show collections

コレクション作成
db.createCollection(“コレクション名”)
※Cは大文字

コレクション削除
db.コレクション名.drop()

ドキュメント作成
db.コレクション名.insert({“name”:”taro”,”age”:1})
db.コレクション名.insert({“name”:”taro”,”age”:1, “addr”:”tokyo”})

ドキュメント検索
db.コレクション名.find()
※すべて

db.コレクション名.findOne()
※一つのみ

db.コレクション名.find({“name”:”taro”})
※条件

ドキュメント更新
db.コレクション名.update(検索内容、更新内容)
db.コレクション名.update({“name”,”taro”},{“name”:”jiro”})

通常はフィールドが全て上書きされる。
更新したい場合$setを使う。
フィールドが存在すれば更新、しないと新しいフィールドとして追加される。

db.コレクション名.update({“name”,”taro”},{$set:{“name”:”jiro”}})

ドキュメント削除
db.コレクション名.remove()
※すべて

db.コレクション名.remove(検索内容)

ユーザー

ユーザーはDBごとに作成adminのユーザーは管理者となる。

現在のDBに接続中のユーザー
db.getUsers()
db.system.users.find()

ユーザ作成
※2.4まではaddUser

use name_store

db.createUser({
user:”taro”,
pwd:”123″,
roles:[{
role: “readWrite”,
db: “admin”
}]
})

あるいは

db.createUser({
user:”jiro”,
pwd:”123″,
roles:[“dbAdminAnyDatabase”]
})

db.createUser({
user:”shiro”,
pwd:”123″,
roles:[“root”]
})

現在の接続先のDBにユーザーがー作成される。
db:は対象のDBというよりロールが存在するDBという意。

主要なロール

read
readWrite
dbAdmin
dbOwner
userAdmin
readAnyDatabase
readWriteAnyDatabase
userAdminAnyDatabase
dbAdminAnyDatabase(他のコレクションのfind等できない)
root

ユーザー削除
use db
db.dropUser(ユーザー名)

認証

認証有効化

/etc/mongod.conf
※winならProgram Filesの中

#security:
↓
security:
__authorization: enabled
※インデント必要

ログイン方法

mongo
use admin
db.auth(“taro”, “123”)

2018-09-052020-05-04

NginxとgolangでAPIサーバー

golangもNginxも始めたばかりなので、他のブログの記事を参考にしつつ試験中

Nginxのconfにlocation追加

location /app1 {
    fastcgi_pass 127.0.0.1:8000;
    include fastcgi_params;
}

location /app1 {

fastcgi_pass 127.0.0.1:8000;

include fastcgi_params;

}

golang

package main

import(
    "net"
    "net/http"
    "net/http/fcgi"
    "text/template"
)

type Html struct{
    Title string
    Get string
}

func handler(w http.ResponseWriter, r *http.Request){

    tmp := r.FormValue("word")

    t, err := template.ParseFiles("base.html")
    if err != nil{
        return
    }
    err = t.Execute(w, &Html{
        Title: "boom",
        Get: tmp,
    })

}

func main(){

    l, err := net.Listen("tcp", "127.0.0.1:8000")
    if err != nil{
        return
    }

    http.HandleFunc("/", handler)
    fcgi.Serve(l, nil)

}

package main

import(

"net"

"net/http"

"net/http/fcgi"

"text/template"

)

type Html struct{

Title string

Get string

}

func handler(w http.ResponseWriter, r *http.Request){

tmp := r.FormValue("word")

t, err := template.ParseFiles("base.html")

if err != nil{

return

}

err = t.Execute(w, &Html{

Title: "boom",

Get: tmp,

})

}

func main(){

l, err := net.Listen("tcp", "127.0.0.1:8000")

if err != nil{

return

}

http.HandleFunc("/", handler)

fcgi.Serve(l, nil)

}

ちょっと違う書き方

upstream app2 {
  server 127.0.0.1:8000;
}

...

location /app2 {
  proxy_pass http://app2/;
}

upstream app2 {

server 127.0.0.1:8000;

}

...

location /app2 {

proxy_pass http://app2/;

}

package main

import(
  "net/http"
)

func main(){

//NewServeMux.Handle(パターン, Handler)となっている
//ServeMuxとはパスごとの処理を登録する構造体
//HandlerFunc(パターン、ハンドラ)が用意されている

  m := http.NewServeMux()
  h := new(MyHandler)
  m.Handle("/", h)

  //ServerはHTTPサーバーのパラメータを指定できる

  s := http.Server{
    Addr: ":8000",
    Handler: m,
  }

  s.ListenAndServe()

}

//MyHandlerはServeHTTPを実装している
//ServeHTTPはHandler Interfaceに定義されている

type MyHandler struct{

}

func (h *MyHandler) ServeHTTP (w http.ResponseWriter, r *http.Request){
  w.Write([]byte("app2!!"))
}

package main

import(

"net/http"

)

func main(){

//NewServeMux.Handle(パターン, Handler)となっている

//ServeMuxとはパスごとの処理を登録する構造体

//HandlerFunc(パターン、ハンドラ)が用意されている

m := http.NewServeMux()

h := new(MyHandler)

m.Handle("/", h)

//ServerはHTTPサーバーのパラメータを指定できる

s := http.Server{

Addr: ":8000",

Handler: m,

}

s.ListenAndServe()

}

//MyHandlerはServeHTTPを実装している

//ServeHTTPはHandler Interfaceに定義されている

type MyHandler struct{

}

func (h *MyHandler) ServeHTTP (w http.ResponseWriter, r *http.Request){

w.Write([]byte("app2!!"))

}

サーバーの開始

func http.ListenAndServe(addr string, handler Handler) err
http.ListenAndServe(“:81”, nil)

第1引数にTCPアドレス
第2引数にHandlerを引数に受け取りサーバーを起動する。

Handlerというのは、http.Handlerインターフェースを実装していればいい。

ちなみに、内部でhttp.server.ListenAndServeを呼んでいる。http.server.ListenAndServeは内部でhttp.Server.Serveを呼んでいる。http.Server.Serveはforループでリクエストごとにgoroutineを立ち上げる。

http.Handle(r)とは

ServeHTTPメソッドを持つインターフェース。
ServeHTTPはリクエストとレスポンスが記述される。
type Handler interface { ServeHTTP(ResponseWriter, *Request) }

http.Handleとは

func Handle(pattern string, handler Handler)
URLとhttp.Handerを実装した構造体を受け取り、ルータに登録。

http.HandleFuncとは

func HandleFunc(pattern string, handler func(ResponseWriter, *Request))
URLとhttp.Handerを受け取り、ルータに登録。

HandleだとServeHTTPを定義しHandlerを実装した構造体を渡す必要があるが、HandleFuncの場合Funcのまま受け取れる。

http.HandleとHandleFuncについて

http内でDefaultServeMux(ServeMux)が定義されており、DefaultServeMux.Handler、DefaultServeMux.HandleFuncが呼ばれている。

http.ServerMuxとは

ServerMuxはURLとhandlerを登録しておく構造体。
ServeMux自体、ServeHTTPメソッドを実装している→Handler
mux := http.NewServeMux()
mux.Handle(“/echo”, echoHandler)

http.Handle(r)Funcとは

type HandlerFunc func(ResponseWriter, *Request)
func(ResponseWriter, *Request)の別名でServerHTTPが定義(実装)されている。

func main() {
m := http.NewServeMux()
m.Handle("/test", http.HandlerFunc(f))
}

func f(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, "Hello World")
}

func main() {

m := http.NewServeMux()

m.Handle("/test", http.HandlerFunc(f))

}

func f(w http.ResponseWriter, r *http.Request) {

w.WriteHeader(http.StatusOK)

fmt.Fprintf(w, "Hello World")

}

Handle(r)FuncとHandleFuncについて

そっくりで混乱するが、HandleFuncはURLとHandlerをServerMuxに登録する。Handle(r)Funcの方は、func(ResponseWriter, *Request)の別名でhttp.Handlerとして使える。

http.ServeMux.HandleFuncとは

URLとfunc(ResponseWriter, *Request)を受け取りルータに登録している

内部でfunc(ResponseWriter, *Request)をHandle(r)FuncにキャストしているHandleに登録している。

m := http.NewServeMux()
m.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, "Hello World")
})

m := http.NewServeMux()

m.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {

w.WriteHeader(http.StatusOK)

fmt.Fprintf(w, "Hello World")

})

http.ServerMux.Handleとは

ServeMuxにURLとHandlerを登録する。

func main() {
m := http.NewServeMux()
m.Handle("/test", handler)
}

type handler struct{}

func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, "Hello World")
}

func main() {

m := http.NewServeMux()

m.Handle("/test", handler)

}

type handler struct{}

func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {

w.WriteHeader(http.StatusOK)

fmt.Fprintf(w, "Hello World")

}

出力関係

Print
標準出力へ

Fprint
出力先を指定

Sprint
文字列で返す。

接尾のfはフォーマット

2018-09-052021-11-02

MuuMuu + Xserver 独自ドメイン

以前、MuuMuuで取得したドメインがあって、NSをXserverに指定したまま放置していたのでこのドメインを活用する。メールはそのままXserverで、wwwのみVPSに回す。

MuuMuuでXserverのネームサーバー(ns[1-5].xserver.p)を指定する。
Xserverのサーバーパネル＞ドメイン設定
から対象ドメインを追加し、
サーバーパネル＞DNSレコード設定
から編集する。

AタイプのIPアドレスをVPSのアドレスに変更する。通常はやらないけど今回はアスタリスクを使ったサブドメインとwww付きを消して1つにしてしまう。

MXはホスト名と内容が同じになっているので、ホスト名をそのまま独自ドメインで、内容をXserverのドメイン(xxx.xsrv.jp)にする。

ホスト名 | A | 210.xxx.xxx.xx | 0
ホスト名 | MX | xxx.xsrv.jp | 0

これでしばらく待つと独自ドメインからSSHアクセスできる。

・DNSレコードについて

A：
ドメインとIPv4を関連づける

MX：
メールサーバー

CNAME：
別名

TXT：
ドメインに関連づけるテキスト情報。主に、メール送信の認証(SPFレコード)に利用される。受信サーバは送信もとアドレスのドメインのTXTレコードを取得しチェックする。

・SPFレコードについて

version qualifier mechanism
という組み合わせになる。

・version：
v=spf1固定

・qualifier：
mechanismでマッチしたらそのメールをどうするかを記号で指定する。

+：
正当なメール

-：
不当なメール(配信しない)

~：
不当なメール(配信する)

?：
指定なし

・mechanism：
送信もとアドレスとマッチするデータを指定する。

ip4：
送信アドレスが一致するか

mx：
MXレコードのIPアドレスと一致するか

a：
AレコードのIPアドレスと一致するか

参考として、
*.domain.com/TXT/v=spf1 +ip4:xxx.xxx.xxx.xxx ~all
ここでは、
+ip4:xxx.xxx.xxx.xxx
と
~all
の２つが指定されている。

例えば、XserverのDNSレコードはどうなっているか。
*.domain.com/TXT/v=spf1 +ip4:xxx.xxx.xxx.xxx ~all
domain.com/TXT/v=spf1 +ip4:xxx.xxx.xxx.xxx ~all
domain.com/A/xxx.xxx.xxx.xxx
*.domain.com/A/xxx.xxx.xxx.xxx
domain.com/MX/domain.com

2018-08-292020-05-06

golang テストで小さいプログラム

golangはじめて間もないので調べつつ色々試験中

標準入力から日付判断

package main

import (
	"bufio"
	"fmt"
	"os"
	"time"
)

func main() {

	today := time.Now().Format("2")

	if today == "29" {
		fmt.Println("hit")
		s := bufio.NewScanner(os.Stdin)
		s.Scan()
	}
}

package main

import (

"bufio"

"fmt"

"os"

"time"

)

func main() {

today := time.Now().Format("2")

if today == "29" {

fmt.Println("hit")

s := bufio.NewScanner(os.Stdin)

s.Scan()

}

SQLite接続

package main

import(
	_ "os"
	"fmt"
	"database/sql"

	_ "github.com/mattn/go-sqlite3"
)

func main(){

	fmt.Println("start")

	db, err := sql.Open("sqlite3", "./test.d")
	if err != nil{
		fmt.Println(err)
		return
	}

	defer db.Close()
	defer fmt.Println("db close")

	_, err = db.Exec("create table t1 (id int)")
	if err != nil{
		fmt.Println(err)
		//return
	}

	_, err = db.Exec("insert into t1 (id) values (2)")
	if err != nil{
		fmt.Println(err)
		return
	}

	var c int
	rows, err := db.Query("select count(*) as c from sqlite_master where name = 't1'")
	if err != nil{
		fmt.Println(err)
		return
	}
	defer rows.Close()
	defer fmt.Println("rows close")

	for rows.Next(){
		err := rows.Scan(&c)
		if err != nil{
			return
		}
		fmt.Println(c)
	}
	fmt.Println("end")
}

package main

import(

_ "os"

"fmt"

"database/sql"

_ "github.com/mattn/go-sqlite3"

)

func main(){

fmt.Println("start")

db, err := sql.Open("sqlite3", "./test.d")

if err != nil{

fmt.Println(err)

return

}

defer db.Close()

defer fmt.Println("db close")

_, err = db.Exec("create table t1 (id int)")

if err != nil{

fmt.Println(err)

//return

}

_, err = db.Exec("insert into t1 (id) values (2)")

if err != nil{

fmt.Println(err)

return

}

var c int

rows, err := db.Query("select count(*) as c from sqlite_master where name = 't1'")

if err != nil{

fmt.Println(err)

return

}

defer rows.Close()

defer fmt.Println("rows close")

for rows.Next(){

err := rows.Scan(&c)

if err != nil{

return

}

fmt.Println(c)

}

fmt.Println("end")

}

サーバー

package main
import (
	"fmt"
	"net/http"
)

type Str string
func (s Str) ServeHTTP(w http.ResponseWriter, r *http.Request){
	fmt.Fprint(w, s)
}

func main() {

	fmt.Println("server is running")

	/* HandleFunc */
	http.HandleFunc("/", handler)

	http.HandleFunc("/b", func(w http.ResponseWriter, r *http.Request){
		fmt.Fprint(w, "Hello b")
	})

	http.HandleFunc("/e", Rec)

	/* Handle */
	http.Handle("/c", Str("hello c"))//ServeHTTPを持った構造体を渡せばOK

	//ファイル配信
	http.Handle("/d", http.StripPrefix("/d", http.FileServer(http.Dir("file"))))
	http.ListenAndServe(":8000", nil)
}

func Rec(w http.ResponseWriter, r *http.Request){
	if r.Method == http.MethodGet{
		fmt.Fprint(w, r.URL.RawQuery)
	}
}

func handler(w http.ResponseWriter, r *http.Request){
	fmt.Fprint(w, "Hello a")
	//fmt.Fprint(w, &url.URL)
}

package main

import (

"fmt"

"net/http"

)

type Str string

func (s Str) ServeHTTP(w http.ResponseWriter, r *http.Request){

fmt.Fprint(w, s)

}

func main() {

fmt.Println("server is running")

/* HandleFunc */

http.HandleFunc("/", handler)

http.HandleFunc("/b", func(w http.ResponseWriter, r *http.Request){

fmt.Fprint(w, "Hello b")

})

http.HandleFunc("/e", Rec)

/* Handle */

http.Handle("/c", Str("hello c"))//ServeHTTPを持った構造体を渡せばOK

//ファイル配信

http.Handle("/d", http.StripPrefix("/d", http.FileServer(http.Dir("file"))))

http.ListenAndServe(":8000", nil)

}

func Rec(w http.ResponseWriter, r *http.Request){

if r.Method == http.MethodGet{

fmt.Fprint(w, r.URL.RawQuery)

}

func handler(w http.ResponseWriter, r *http.Request){

fmt.Fprint(w, "Hello a")

//fmt.Fprint(w, &url.URL)

}

SSH接続

package main
import(
	"io/ioutil"
	"golang.org/x/crypto/ssh"
)

func main(){
	ip := "xxx"
	port := "xxx"
	user := "xxx"

buf, err := ioutil.ReadFile("t.pem")
if err != nil{
	return
}
key, err := ssh.ParsePrivateKey(buf)
if err != nil{
	return
}

config := &ssh.ClientConfig{
	User: user,
	Auth: []ssh.AuthMethod{
		ssh.PublicKeys(key),
	},
	HostKeyCallback: ssh.InsecureIgnoreHostKey(),
}

conn, err := ssh.Dial("tcp", ip + ":" + port, config)
if err != nil{
	return
}
defer conn.Close()

session, err := conn.NewSession()
if err != nil{
	return
}
defer session.Close()

session.Run("echo -n > a.txt")

}

package main

import(

"io/ioutil"

"golang.org/x/crypto/ssh"

)

func main(){

ip := "xxx"

port := "xxx"

user := "xxx"

buf, err := ioutil.ReadFile("t.pem")

if err != nil{

return

}

key, err := ssh.ParsePrivateKey(buf)

if err != nil{

return

}

config := &ssh.ClientConfig{

User: user,

Auth: []ssh.AuthMethod{

ssh.PublicKeys(key),

HostKeyCallback: ssh.InsecureIgnoreHostKey(),

}

conn, err := ssh.Dial("tcp", ip + ":" + port, config)

if err != nil{

return

}

defer conn.Close()

session, err := conn.NewSession()

if err != nil{

return

}

defer session.Close()

session.Run("echo -n > a.txt")

}

他言語で言うクラス

package main

import(
  "fmt"
)

type greeting struct{
  words string
}

func (g *greeting) sayHello(){
  fmt.Println(g.words)
}

func main(){

  s := &greeting{
    words : "hello world",
  }

  s.sayHello() //hello world

}

package main

import(

"fmt"

)

type greeting struct{

words string

}

func (g *greeting) sayHello(){

fmt.Println(g.words)

}

func main(){

s := &greeting{

words : "hello world",

}

s.sayHello() //hello world

}

json読み込み

package main

import(
  "fmt"
  "io/ioutil"
  "encoding/json"
)

type Personal struct{
  Name string `json:"addr"`
  Age int
}

//こう書くとjsonのaddrキーがマッピングされる

func main(){

  b, err := ioutil.ReadFile("./data.json")
  if err != nil{
    panic(err)
  }

  //直接書く場合
  //b := []byte(`{ "name":"taro", "age":20 }`)

  var p Personal
  if err := json.Unmarshal(b, &p); err != nil{
    panic(err)
  }

  fmt.Println(p.Name)
}

package main

import(

"fmt"

"io/ioutil"

"encoding/json"

)

type Personal struct{

Name string `json:"addr"`

Age int

}

//こう書くとjsonのaddrキーがマッピングされる

func main(){

b, err := ioutil.ReadFile("./data.json")

if err != nil{

panic(err)

}

//直接書く場合

//b := []byte(`{ "name":"taro", "age":20 }`)

var p Personal

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

panic(err)

}

fmt.Println(p.Name)

}

時間

package main

import(
  "time"
  "math/rand"
)

func main(){

  //日付取得
  println(time.Now().Format("2006-01-02"))

  //UNIXタイム
  println(time.Now().Unix())

  //乱数
  println(rand.Int63())

  //時刻Seed
  rand.Seed(time.Now().UnixNano())

  for i := 1; i <= 2; i++{
    //63bit
    println(rand.Int63())
    //n付きは範囲
    println(rand.Intn(10))
  }
}

package main

import(

"time"

"math/rand"

)

func main(){

//日付取得

println(time.Now().Format("2006-01-02"))

//UNIXタイム

println(time.Now().Unix())

//乱数

println(rand.Int63())

//時刻Seed

rand.Seed(time.Now().UnixNano())

for i := 1; i <= 2; i++{

//63bit

println(rand.Int63())

//n付きは範囲

println(rand.Intn(10))

}

2018-08-292020-05-06

golang インストールメモ

最近golangをはじめたので。

WSLインストール

sudo apt-get update
sudo apt-get install golang

バージョン確認
go version

> 1.6.2

環境確認
go env

.bashrcに追加
export GOPATH=”$HOME/go”
export PATH=”$GOPATH/bin:$PATH”

Db(SQLite)を使ってみる

go get github.com/mattn/go-sqlite3

package context: unrecognized import path “context”
というエラーがでる。

1.7ではcontextパッケージとして標準パッケージに仲間入りする。
とのことなのでアップデート

sudo apt-get install golang-1.9
sudo mv /usr/bin/go /usr/bin/go.old
sudo mv /usr/bin/gofmt /usr/bin/gofmt.old
sudo ln -s /usr/lib/go-1.9/bin/go /usr/bin/go
sudo ln -s /usr/lib/go-1.9/bin/gofmt /usr/bin/gofmt

これで入った。

Windows用にクロスコンパイル

WSLからだと通常こうなっているので、
GOOS=linux
以下の用にしてビルド
GOOS=windows go build hello.go

2018-08-29

VBS 起動にちょっとアラート

普通Gカレンダとか使うんだけど。

today = Day(Now())

'必要に応じて日を追加
If today = 1 Then MsgBox "何か書く"

'月末用
monthAdded = DateAdd("m", 1, Now)
nextMonth = DateValue(Year(monthAdded) & "/" & Month(monthAdded) & "/" & "1")
lastDay = Day(DateAdd("d", -1, nextMonth))

If today = lastDay Then MsgBox "何か書く"

today = Day(Now())

'必要に応じて日を追加

If today = 1 Then MsgBox "何か書く"

'月末用

monthAdded = DateAdd("m", 1, Now)

nextMonth = DateValue(Year(monthAdded) & "/" & Month(monthAdded) & "/" & "1")

lastDay = Day(DateAdd("d", -1, nextMonth))

If today = lastDay Then MsgBox "何か書く"

投稿者: okamura

golang クロージャ

golang sshでdbのバックアップ

golang色々

golang+MongoDB+Vue.js 色々

MongoDB基礎

インストール

Mongoシェルコマンド

ユーザー

主要なロール

認証

NginxとgolangでAPIサーバー

サーバーの開始

http.Handle(r)とは

http.Handleとは

http.HandleFuncとは

http.HandleとHandleFuncについて

http.ServerMuxとは

http.Handle(r)Funcとは

Handle(r)FuncとHandleFuncについて

http.ServeMux.HandleFuncとは

http.ServerMux.Handleとは

出力関係

MuuMuu + Xserver 独自ドメイン

golang テストで小さいプログラム

golang インストールメモ

WSLインストール

Db(SQLite)を使ってみる

Windows用にクロスコンパイル

VBS 起動にちょっとアラート