srv
\-- salt
   \-- _modules
       \-- foo.py
   \-- prod
   ...

# coding: utf-8

def bar():
    CMD_RUN = __salt__['cmd.run']
    cmd = "ls /etc/init"
    return CMD_RUN(cmd)

# 解释
# 自定义模块会加载__salt__变量，这个dict变量里包含所有的salt function
# 上面的cmd.run就是salt的命令运行函数
# __salt__变量必须在自定义的模块里使用，也就是必须在自定一的方法中使用，
# 如上面的bar方法，不能将__salt__变量放到全局变量中使用，否则会报__salt__变量为定义

# 运行
salt '*' state.highstate
# 会让所有的minion到master上来取走自己的SLS定义

# 模拟运行
salt 'minion1.example.com' state.highstate -v test=True

# 修改/etc/salt/master文件，去掉如下注释
file_roots:
  base:
    - /srv/salt
  prod:
    - /srv/salt/prod
  dev:
    - /srv/salt/dev


# 如果需要使用pillar，去掉如下注释
# pillar可以允许你定义一些变量，敏感数据，具体参考 http://www.ituring.com.cn/article/42398
pillar_root:
  base:
    - /srv/pillar

tops.sls （描述所有客户端需要执行的状态）
prod （生产环境配置）
  -- core （基本软件安装）
     -- core.sls
  -- nginx
     -- nginx.sls
     -- nginx.conf
  -- vim
     -- vim.sls
     -- vim.local
  -- git
     -- git.sls
  -- web
     -- web.sls
  -- ...
     -- ...
dev （测试环境配置）
  -- ...
     -- ...

# /srv/salt/tops.sls
prod:
  '*':   # 所有minion都要获取core状态
    - core.core

# /srv/salt/prod/core/core.sls
mypkgs:
  pkg.installed:
    - pkgs:
      - gcc
      - python-dev
      - tmux
      - build-essential
      - g++
      - ...

(ns clojuresql.core)

;;; jdbc 驱动
(require '[clojure.java.jdbc :as jdbc])

;;; 数据库配置
(def db-spec {
              :subprotocol "mysql"
              :subname "//172.17.8.101:3306/didi_db"
              :user "admin"
              :password "root"})

;;; Select 语句处理
(defn select
  [fields]
  (clojure.string/join
   " "
   (concat
    ["SELECT"]
    [(clojure.string/join
    ", "
    fields)])))

;;; from 语句处理
(defn from
  [& table]
  (clojure.string/join " " (concat ["FROM"] table)))

;;; 定义控制结构
(defmacro cljsql
  [& sql_atom]
  `(jdbc/query
    db-spec
    [(clojure.string/join " " (list ~@sql_atom))])
  )

;;; 使用
(cljsql (select ["username", "password"])
        (from "auth_user"))

// return http request channels
func RequestsChans(conn net.Conn) chan *Request {
        reader := bufio.NewReader(conn)
        reqCap := config.SerConfig.ReqChanCap
        reqChans := make(chan *Request, reqCap)

        go func() {
                reqSlice := make([]string, reqCap)
                for {
                        line, err := reader.ReadString('\n')
                        if err == nil {
                                line = strings.TrimSpace(line)
                                reqSlice = append(reqSlice, line)
                                if len(line) == 0 {
                                        req := parseRequest(reqSlice)
                                        loggerReqInfo(conn, req)
                                        reqChans <- req
                                        reqSlice = reqSlice[:0]
                                }
                        } else {
                                logger.Logger.Debug(
                                        "Ip %s connection close, close msg %s",
                                        conn.RemoteAddr().String(),
                                        err.Error(),
                                )
                                conn.Close()
                                break
                        }
                }
                close(reqChans)
        }()
        return reqChans
}

/* 定义一个形状类
   实现正方形计算面积的方法
   实现圆计算面积的方法
*/
type Sharp struct {
    r float64
}

func (s Sharp) Square() float64{
    return s.r * s.r
}

func (s Sharp) Circle() float64{
    return s.r * s.r * 3.14
}

type Area interface {
    Square() float64
    Circle() float64
}
/* 上面类的例子没有继承接口，但是实现了接口的方法，接口无需继承 */
/* 使用 */
var sharp Area = &sharp{4}
sharp.Square()
sharp.Circle()

package main

import "fmt"

/* 定义一个形状类
   实现正方形计算面积的方法
   实现圆计算面积的方法
*/
type Sharp struct {
        r float64
}

func (s Sharp) Square() float64 {
        return s.r * s.r
}

func (s Sharp) Circle() float64 {
        return s.r * s.r * 3.14
}

type Area interface {
        Square() float64
        Circle() float64
}

func main() {
        // 实例化类方法, 引用
        var sharpSquare Sharp = Sharp{4}
        var sharpCircle Sharp = Sharp{4}

        // 实例化类方法，指针
        var sharpSquare1 *Sharp = &Sharp{4}
        var sharpCircle1 *Sharp = &Sharp{4}

        // 实例化类方法, 使用new关键字
        // new 分配了0值填充的Sharp类型的内存空间，并且返回该空间的地址
        sharpSquare2 := new(Sharp)
        sharpSquare2.r = 5

        fmt.Println("引用")
        fmt.Println(sharpSquare.Square())
        fmt.Println(sharpCircle.Circle())

        fmt.Println("指针")
        fmt.Println(sharpSquare1.Square())
        fmt.Println(sharpCircle1.Circle())

        fmt.Println("new关键字")
        fmt.Println(sharpSquare2.Circle())

        // Sharp 实现了接口的两个方法，已经实现了该接口
        // 接口调用
        fmt.Println("接口")
        var area1 Area = Sharp{6}
        fmt.Println(area1.Square())
        fmt.Println(area1.Circle())
}

package main

import (
        "fmt"
)
/*
    定义Square和Circle两个类
    分别实现Area方法
    定义接口PolySharp，接口方法Area
    Square和Circle相当于实现了接口PolySharp
*/
type Square struct {
        width float64
}

type Circle struct {
        redius float64
}

func (s Square) Area() float64 {
        return s.width * s.width
}

func (s Circle) Area() float64 {
        return s.redius * s.redius * 3.14
}

type PolySharp interface {
        Area() float64
}

func main() {
        var s1 PolySharp = &Square{4}
        var s2 PolySharp = &Circle{4}
        fmt.Println(s1.Area())
        fmt.Println(s2.Area())
}

type mytype int
func (p mytype) funcname(i int) (r int) {
    return 0
}

// 关键字func， 绑定到mytype上（叫做方法method）， 函数名， 返回类型

package main

import "fmt"

func byval(a int) {
    a += 5
    fmt.Println(a)
}

func byref(a *int) {
    fmt.Println(a)
    *a += 5
    fmt.Println(a)
}

func main() {
    a := 4;
    fmt.Println(a)
    byval(a)
    fmt.Println(a)
    byref(&a)
    fmt.Println(a)
}

/* result
4
9
4
9
9
*/