FROM golang:1.9.-alpine3.

COPY . $GOPATH/src/database-work

WORKDIR $GOPATH/src/database-work/server

RUN go build -o main main.go

ENTRYPOINT ["./main"]

# must use ./main

#!/bin/bash

不能有空格，在#和!中

// [_Command-line flags_](http://en.wikipedia.org/wiki/Command-line_interface#Command-line_option)

// are a common way to specify options for command-line

// programs. For example, in `wc -l` the `-l` is a

// command-line flag.

package main

// Go provides a `flag` package supporting basic

// command-line flag parsing. We'll use this package to

// implement our example command-line program.

import "flag"

import "fmt"

func main() {

    // Basic flag declarations are available for string,

    // integer, and boolean options. Here we declare a

    // string flag `word` with a default value `"foo"`

    // and a short description. This `flag.String` function

    // returns a string pointer (not a string value);

    // we'll see how to use this pointer below.

    wordPtr := flag.String("word", "default_word", "a string")

    // This declares `numb` and `fork` flags, using a

    // similar approach to the `word` flag.

    numbPtr := flag.Int("wordnumb", , "an int"). // 这样也可以，前缀相同

    // nextPtr := flag.Int("numb", 0, "an int")

    boolPtr := flag.Bool("fork", false, "a bool")

    // It's also possible to declare an option that uses an

    // existing var declared elsewhere in the program.

    // Note that we need to pass in a pointer to the flag

    // declaration function.

    var svar string

    flag.StringVar(&svar, "svar", "defalut_var", "a string var")

    // Once all flags are declared, call `flag.Parse()`

    // to execute the command-line parsing.

    flag.Parse()

    // Here we'll just dump out the parsed options and

    // any trailing positional arguments. Note that we

    // need to dereference the pointers with e.g. `*wordPtr`

    // to get the actual option values.

    fmt.Println("word:", *wordPtr)

    fmt.Println("numb:", *numbPtr)

    fmt.Println("fork:", *boolPtr)

    // fmt.Println("next:", *nextPtr)

    fmt.Println("svar:", svar)

    fmt.Println("tail:", flag.Args())

}

function migrate() {

    version=`date +%s`

    if [ ${defaultname}x == ""x ]

    then    defaultname="defaultname"

    fi

    touch ./db/migrations/${version}_${defaultname}.up.sql

    touch ./db/migrations/${version}_${defaultname}.down.sql

}

  dbrestore:

    image: mysql:5.7

    environment:

      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}

      - DC_DB_HOST=${DC_DB_HOST}

      - DC_DB_SSL_MODE=${DC_DB_SSL_MODE}

      - MYSQL_DATABASE=${MYSQL_DATABASE}

    volumes:

      - ../db:/db

      - ../tools:/tools

    depends_on:

      - db

    links:

      - db

    command: "./tools/deploy.sh dbrestore"

package seq

import (

    "sync"

    "github.com/sundayfun/daycam-server/db"

    "github.com/sundayfun/daycam-server/db/model"

)

// TODO: fix temp seq id

var (

    userMutex = make(map[uint64]*sync.Mutex)

    existUser = make(map[uint64]uint64)

    lock      = &sync.Mutex{}

)

const (

    base =

)

func init() {

}

func whetherExist(uid uint64) uint64 {

    if seq, ok := existUser[uid]; ok {

        userMutex[uid].Lock()

        defer userMutex[uid].Unlock()

        existUser[uid] = seq +

        return seq

    }

    return  // zero refer to does not exist

}

func NextSequenceIDByUser(uid uint64) uint64 {

    seq := whetherExist(uid)

    if seq !=  { // user exist

        return seq

    }

    lock.Lock()

    defer lock.Unlock()

    seq = whetherExist(uid)

    if seq !=  { // user exist

        return seq

    }

    // first time to start main.go

    userMutex[uid] = &sync.Mutex{}

    userMutex[uid].Lock()

    defer userMutex[uid].Unlock()

    seq := model.LatestSeqByUser(db.GlobalDB, uid)

    existUser[uid] = seq +

    return seq +

}