/**
* parse split chars and return value
*/
func parse_split(split string) (id byte, value int, err error) {
split = strings.ToLower(split)
switch split {
case "day":
id, value = SPLIT_DAY, 1
default:
if strings.HasSuffix(split, "hour") {
id = SPLIT_HOUR
value, err = strconv.Atoi(strings.TrimSuffix(split, "hour"))
//fix illegal hour
if err == nil && (value < 1 || value > 23) {
value = 1
}
} else if strings.HasSuffix(split, "min") {
id = SPLIT_MIN
value, err = strconv.Atoi(strings.TrimSuffix(split, "min"))
//fix illegal minute
if err == nil && (value > 60 || value < 5) {
value = 5
}
} else if strings.HasSuffix(split, "m") {
id = SPLIT_SIZE
value, err = strconv.Atoi(strings.TrimSuffix(split, "m"))
//fix illegal size
if err == nil && value < 1 {
value = 1
}
} else {
err = errors.New("unknow split")
}
}
return
}
func getTeamMembers(c *Context, w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
offset, err := strconv.Atoi(params["offset"])
if err != nil {
c.SetInvalidParam("getTeamMembers", "offset")
return
}
limit, err := strconv.Atoi(params["limit"])
if err != nil {
c.SetInvalidParam("getTeamMembers", "limit")
return
}
if c.Session.GetTeamByTeamId(c.TeamId) == nil {
if !HasPermissionToTeamContext(c, c.TeamId, model.PERMISSION_MANAGE_SYSTEM) {
return
}
}
if result := <-Srv.Store.Team().GetMembers(c.TeamId, offset, limit); result.Err != nil {
c.Err = result.Err
return
} else {
members := result.Data.([]*model.TeamMember)
w.Write([]byte(model.TeamMembersToJson(members)))
return
}
}
func (s *apiService) getDBNeed(w http.ResponseWriter, r *http.Request) {
qs := r.URL.Query()
folder := qs.Get("folder")
page, err := strconv.Atoi(qs.Get("page"))
if err != nil || page < 1 {
page = 1
}
perpage, err := strconv.Atoi(qs.Get("perpage"))
if err != nil || perpage < 1 {
perpage = 1 << 16
}
progress, queued, rest, total := s.model.NeedFolderFiles(folder, page, perpage)
// Convert the struct to a more loose structure, and inject the size.
sendJSON(w, map[string]interface{}{
"progress": s.toNeedSlice(progress),
"queued": s.toNeedSlice(queued),
"rest": s.toNeedSlice(rest),
"total": total,
"page": page,
"perpage": perpage,
})
}
func (this *Zktop) displayZoneTop(zkzone *zk.ZkZone) {
if this.batchMode {
this.Ui.Output(fmt.Sprintf("%s %s", zkzone.Name(), bjtime.NowBj()))
} else {
this.Ui.Output(color.Green(zkzone.Name()))
}
header := "VER SERVER PORT M OUTST RECVD SENT CONNS ZNODES LAT(MIN/AVG/MAX)"
this.Ui.Output(header)
stats := zkzone.RunZkFourLetterCommand("stat")
sortedHosts := make([]string, 0, len(stats))
for hp, _ := range stats {
sortedHosts = append(sortedHosts, hp)
}
sort.Strings(sortedHosts)
for _, hostPort := range sortedHosts {
host, port, err := net.SplitHostPort(hostPort)
if err != nil {
panic(err)
}
stat := zk.ParseStatResult(stats[hostPort])
if stat.Mode == "" {
if this.batchMode {
stat.Mode = "E"
} else {
stat.Mode = color.Red("E")
}
} else if stat.Mode == "L" && !this.batchMode {
stat.Mode = color.Blue(stat.Mode)
}
var sentQps, recvQps int
if lastRecv, present := this.lastRecvs[hostPort]; present {
r1, _ := strconv.Atoi(stat.Received)
r0, _ := strconv.Atoi(lastRecv)
recvQps = (r1 - r0) / int(this.refreshInterval.Seconds())
s1, _ := strconv.Atoi(stat.Sent)
s0, _ := strconv.Atoi(this.lastSents[hostPort])
sentQps = (s1 - s0) / int(this.refreshInterval.Seconds())
}
this.Ui.Output(fmt.Sprintf("%-15s %-15s %5s %1s %6s %16s %16s %5s %7s %s",
stat.Version, // 15
host, // 15
port, // 5
stat.Mode, // 1
stat.Outstanding, // 6
fmt.Sprintf("%s/%d", stat.Received, recvQps), // 16
fmt.Sprintf("%s/%d", stat.Sent, sentQps), // 16
stat.Connections, // 5
stat.Znodes, // 7
stat.Latency,
))
this.lastRecvs[hostPort] = stat.Received
this.lastSents[hostPort] = stat.Sent
}
}
func schedules(w http.ResponseWriter, r *http.Request) {
minUnits, err := strconv.Atoi(r.FormValue("minUnits"))
if err != nil {
minUnits = 0
}
maxUnits, err := strconv.Atoi(r.FormValue("maxUnits"))
if err != nil {
maxUnits = math.MaxInt32
}
schedules, err := generateSchedulesJSON([]byte(r.FormValue("classes")),
minUnits, maxUnits)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
t, err := texttemplate.ParseFiles("schedules.html")
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
t.Execute(w, schedules)
}
func (me Version) compareTo(other Version) int {
var (
meTab = strings.Split(string(me), ".")
otherTab = strings.Split(string(other), ".")
)
max := len(meTab)
if len(otherTab) > max {
max = len(otherTab)
}
for i := 0; i < max; i++ {
var meInt, otherInt int
if len(meTab) > i {
meInt, _ = strconv.Atoi(meTab[i])
}
if len(otherTab) > i {
otherInt, _ = strconv.Atoi(otherTab[i])
}
if meInt > otherInt {
return 1
}
if otherInt > meInt {
return -1
}
}
return 0
}
// +0700 -> 07*60*60 + 30*60
func timeOffsetStrToInt(s string) (int, error) {
if len(s) != 5 {
return 0, errInvalidOffset
}
if s[0] != '+' && s[0] != '-' {
return 0, errInvalidOffset
}
hStr, mStr := s[1:3], s[3:5]
h, err := strconv.Atoi(hStr)
if err != nil {
return 0, err
}
m, err := strconv.Atoi(mStr)
if err != nil {
return 0, err
}
switch s[0] {
case '+':
return h*60*60 + m*60, nil
case '-':
return -h*60*60 - m*60, nil
}
return 0, errInvalidOffset
}
func main() {
flag.Parse()
args := flag.Args()
num_iters, _ := strconv.Atoi(args[0])
num_workers, _ := strconv.Atoi(args[1])
mutex := &sync.Mutex{}
x := 0
done := make(chan bool)
for i := 0; i < num_workers; i++ {
go func() {
for j := 0; j < num_iters; j++ {
mutex.Lock()
x++
mutex.Unlock()
}
done <- true
}()
}
for i := 0; i < num_workers; i++ {
<-done
}
fmt.Printf("%d\n", x)
}
func user(res http.ResponseWriter, req *http.Request) {
LogRequest(req)
params := req.URL.Query()
if len(params["facebook_id"]) > 0 {
facebook_id_int, _ := strconv.Atoi(params["facebook_id"][0])
// facebook id is present
facebook_id := int64(facebook_id_int)
user := UserFromFB(facebook_id)
if user.Id == 0 {
// no such user
NoSuchUser(res)
return
}
user_json := ToJson(user)
fmt.Fprintf(res, string(user_json))
} else if len(params["id"]) > 0 {
owner_id_int, _ := strconv.Atoi(params["id"][0])
owner_id := int64(owner_id_int)
user := UserFromID(owner_id)
if user.Facebook_id == 0 {
// no such user
NoSuchUser(res)
return
}
user_json := ToJson(user)
fmt.Fprintf(res, string(user_json))
} else {
var errors = map[string]string{
"error": "Missing facebook_id or id",
}
e_json := ToJson(errors)
fmt.Fprintf(res, string(e_json))
}
}
func main() {
s := bufio.NewScanner(bufio.NewReader(os.Stdin))
s.Split(bufio.ScanWords)
s.Scan()
m, _ := strconv.Atoi(s.Text())
s.Scan()
n, _ := strconv.Atoi(s.Text())
a := make([][]int, m)
for i := 0; i < m; i++ {
a[i] = make([]int, n)
for j := 0; j < n; j++ {
s.Scan()
a[i][j], _ = strconv.Atoi(s.Text())
}
}
max := 0
for i := 0; i < m; i++ {
for j := 0; j < n; j++ {
if a[i][j] == 1 {
v := mark(a, i, j, m, n)
if max < v {
max = v
}
}
}
}
Println(max)
}
// Load decode Lllvar field from bytes
func (l *Lllvar) Load(raw []byte, encoder, lenEncoder, length int) (read int, err error) {
// parse length head:
var contentLen int
switch lenEncoder {
case ASCII:
read = 3
contentLen, err = strconv.Atoi(string(raw[:read]))
if err != nil {
return 0, errors.New(ERR_PARSE_LENGTH_FAILED + ": " + string(raw[:3]))
}
case rBCD:
fallthrough
case BCD:
read = 2
contentLen, err = strconv.Atoi(string(bcdr2Ascii(raw[:read], 3)))
if err != nil {
return 0, errors.New(ERR_PARSE_LENGTH_FAILED + ": " + string(raw[:2]))
}
default:
return 0, errors.New(ERR_INVALID_LENGTH_ENCODER)
}
if len(raw) < (read + contentLen) {
return 0, errors.New(ERR_BAD_RAW)
}
// parse body:
l.Value = raw[read : read+contentLen]
read += contentLen
if encoder != ASCII {
return 0, errors.New(ERR_INVALID_ENCODER)
}
return read, nil
}
func getValidationRules(m reflect.StructField) (map[string]interface{}, error) {
tags := make(map[string]interface{})
if tagType := m.Tag.Get(TypeTag); tagType != "" {
switch tagType {
case EmailTag:
tags[EmailTag] = true
case PhoneIndiaTag:
tags[PhoneIndiaTag] = true
}
}
if tagVal := m.Tag.Get(EmailTag); tagVal != "" {
boolVal, err := strconv.ParseBool(tagVal)
if err != nil {
panic(err)
}
if boolVal {
tags[EmailTag] = boolVal
}
}
if tagVal := m.Tag.Get(RequiredTag); tagVal != "" {
boolVal, err := strconv.ParseBool(tagVal)
if err != nil {
panic(err)
}
if boolVal {
tags[RequiredTag] = boolVal
}
}
if tagVal := m.Tag.Get(PhoneIndiaTag); tagVal != "" {
boolVal, err := strconv.ParseBool(tagVal)
if err != nil {
panic(err)
}
if boolVal {
tags[PhoneIndiaTag] = boolVal
}
}
if tagVal := m.Tag.Get(MaxLenTag); tagVal != "" {
maxLen, err := strconv.Atoi(tagVal)
if err == nil {
tags[MaxLenTag] = maxLen
}
}
if tagVal := m.Tag.Get(MinLenTag); tagVal != "" {
minLen, err := strconv.Atoi(tagVal)
if err == nil {
tags[MinLenTag] = minLen
}
}
return tags, nil
}
// Takes care of dropping privileges to the desired user
func changeUser(args *DockerInitArgs) error {
if args.user == "" {
return nil
}
userent, err := utils.UserLookup(args.user)
if err != nil {
return fmt.Errorf("Unable to find user %v: %v", args.user, err)
}
uid, err := strconv.Atoi(userent.Uid)
if err != nil {
return fmt.Errorf("Invalid uid: %v", userent.Uid)
}
gid, err := strconv.Atoi(userent.Gid)
if err != nil {
return fmt.Errorf("Invalid gid: %v", userent.Gid)
}
if err := syscall.Setgid(gid); err != nil {
return fmt.Errorf("setgid failed: %v", err)
}
if err := syscall.Setuid(uid); err != nil {
return fmt.Errorf("setuid failed: %v", err)
}
return nil
}
func (*MessagesController) buildCriteria(ctx *gin.Context) *models.MessageCriteria {
c := models.MessageCriteria{}
skip, e := strconv.Atoi(ctx.DefaultQuery("skip", "0"))
if e != nil {
skip = 0
}
c.Skip = skip
limit, e2 := strconv.Atoi(ctx.DefaultQuery("limit", "100"))
if e2 != nil {
limit = 10
}
c.Limit = limit
c.TreeView = ctx.Query("treeView")
c.IDMessage = ctx.Query("idMessage")
c.InReplyOfID = ctx.Query("inReplyOfID")
c.InReplyOfIDRoot = ctx.Query("inReplyOfIDRoot")
c.AllIDMessage = ctx.Query("allIDMessage")
c.Text = ctx.Query("text")
c.Label = ctx.Query("label")
c.NotLabel = ctx.Query("notLabel")
c.AndLabel = ctx.Query("andLabel")
c.Tag = ctx.Query("tag")
c.NotTag = ctx.Query("notTag")
c.AndTag = ctx.Query("andTag")
c.DateMinCreation = ctx.Query("dateMinCreation")
c.DateMaxCreation = ctx.Query("dateMaxCreation")
c.DateMinUpdate = ctx.Query("dateMinUpdate")
c.DateMaxUpdate = ctx.Query("dateMaxUpdate")
c.Username = ctx.Query("username")
return &c
}
// tileHandler implements a tile renderer for use with the Google Maps JavaScript API.
// See http://code.google.com/apis/maps/documentation/javascript/maptypes.html#ImageMapTypes
func tileHandler(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
x, _ := strconv.Atoi(r.FormValue("x"))
y, _ := strconv.Atoi(r.FormValue("y"))
z, _ := strconv.Atoi(r.FormValue("z"))
w.Header().Set("Content-Type", "image/png")
// Try memcache first.
key := fmt.Sprintf("mandelbrot:%d/%d/%d", x, y, z)
if z < maxMemcacheLevel {
if item, err := memcache.Get(c, key); err == nil {
w.Write(item.Value)
return
}
}
b := render(x, y, z)
if z < maxMemcacheLevel {
memcache.Set(c, &memcache.Item{
Key: key,
Value: b,
Expiration: 3600, // TTL = 1 hour
})
}
w.Header().Set("Content-Length", strconv.Itoa(len(b)))
w.Write(b)
}
func discoveryOpts(clusterOpts map[string]string) (time.Duration, time.Duration, error) {
var (
heartbeat = defaultDiscoveryHeartbeat
ttl = defaultDiscoveryTTLFactor * defaultDiscoveryHeartbeat
)
if hb, ok := clusterOpts["discovery.heartbeat"]; ok {
h, err := strconv.Atoi(hb)
if err != nil {
return time.Duration(0), time.Duration(0), err
}
heartbeat = time.Duration(h) * time.Second
ttl = defaultDiscoveryTTLFactor * heartbeat
}
if tstr, ok := clusterOpts["discovery.ttl"]; ok {
t, err := strconv.Atoi(tstr)
if err != nil {
return time.Duration(0), time.Duration(0), err
}
ttl = time.Duration(t) * time.Second
if _, ok := clusterOpts["discovery.heartbeat"]; !ok {
h := int(t / defaultDiscoveryTTLFactor)
heartbeat = time.Duration(h) * time.Second
}
if ttl <= heartbeat {
return time.Duration(0), time.Duration(0),
fmt.Errorf("discovery.ttl timer must be greater than discovery.heartbeat")
}
}
return heartbeat, ttl, nil
}
// ParseHTTPVersion parses a HTTP version string.
// "HTTP/1.0" returns (1, 0, true).
func ParseHTTPVersion(vers string) (major, minor int, ok bool) {
const Big = 1000000 // arbitrary upper bound
switch vers {
case "HTTP/1.1":
return 1, 1, true
case "HTTP/1.0":
return 1, 0, true
}
if !strings.HasPrefix(vers, "HTTP/") {
return 0, 0, false
}
dot := strings.Index(vers, ".")
if dot < 0 {
return 0, 0, false
}
major, err := strconv.Atoi(vers[5:dot])
if err != nil || major < 0 || major > Big {
return 0, 0, false
}
minor, err = strconv.Atoi(vers[dot+1:])
if err != nil || minor < 0 || minor > Big {
return 0, 0, false
}
return major, minor, true
}
func main() {
var separator string
flag.StringVar(&separator, "s", "\n", "Element separator")
flag.Parse()
var first, last int
var err error
if len(flag.Args()) == 1 {
first = 1
if last, err = strconv.Atoi(flag.Args()[0]); err != nil {
fmt.Println(err)
return
}
} else if len(flag.Args()) == 2 {
if first, err = strconv.Atoi(flag.Args()[0]); err != nil {
fmt.Println(err)
return
}
if last, err = strconv.Atoi(flag.Args()[1]); err != nil {
fmt.Println(err)
return
}
}
for i := first; i <= last; i++ {
fmt.Printf("%d%s", i, separator)
}
}
func intOp(op token.Token, x, y *BasicLit, combine bool) (*BasicLit, error) {
out := &BasicLit{
Kind: x.Kind,
}
l, err := strconv.Atoi(x.Value)
if err != nil {
return out, err
}
r, err := strconv.Atoi(y.Value)
if err != nil {
return out, err
}
var t int
switch op {
case token.ADD:
t = l + r
case token.SUB:
t = l - r
case token.QUO:
// Sass division can create floats, so much treat
// ints as floats then test for fitting inside INT
fl, fr := float64(l), float64(r)
if math.Remainder(fl, fr) != 0 {
return floatOp(op, x, y, combine)
}
t = l / r
case token.MUL:
t = l * r
default:
panic("unsupported intOp" + op.String())
}
out.Value = strconv.Itoa(t)
return out, nil
}
func TestQuickUnion(t *testing.T) {
file, err := os.Open("tinyUF.txt")
if err != nil {
t.Errorf("Error opening File")
}
defer file.Close()
scanner := bufio.NewScanner(file)
scanner.Split(bufio.ScanWords)
scanner.Scan()
size, _ := strconv.Atoi(scanner.Text())
uf := initQuickUnionUF(size)
for scanner.Scan() {
x, _ := strconv.Atoi(scanner.Text())
scanner.Scan()
y, _ := strconv.Atoi(scanner.Text())
uf.union(x, y)
}
if conn := uf.connected(6, 1); conn != true {
t.Errorf("Error")
}
}
func main() {
//With ParseFloat, this 64 tells how many bits of precision to parse.
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f)
//For ParseInt, the 0 means infer the base from the string. 64 requires that the result fit in 64 bits.
i, _ := strconv.ParseInt("123", 0, 64)
fmt.Println(i)
//ParseInt will recognize hex-formatted numbers.
d, _ := strconv.ParseInt("0x1c8", 0, 64)
fmt.Println(d)
//A ParseUint is also available.
u, _ := strconv.ParseUint("789", 0, 64)
fmt.Println(u)
//Atoi is a convenience function for basic base-10 int parsing.
k, _ := strconv.Atoi("135")
fmt.Println(k)
//Parse functions return an error on bad input.
_, e := strconv.Atoi("wat")
fmt.Println(e)
}
// 加载更多link
func discover_loadMoreLink(ctx *goku.HttpContext) goku.ActionResulter {
page, err := strconv.Atoi(ctx.Get("page"))
success, hasmore := false, false
errorMsgs, html := "", ""
if err == nil && page > 1 {
ot := ctx.Get("o")
if ot == "" {
ot = "hot"
}
dt, _ := strconv.Atoi(ctx.Get("dt"))
links, _ := models.LinkForHome_GetByPage(ot, dt, page, golink.PAGE_SIZE)
if links != nil && len(links) > 0 {
ctx.ViewData["Links"] = models.Link_ToVLink(links, ctx)
vr := ctx.RenderPartial("loadmorelink", nil)
vr.Render(ctx, vr.Body)
html = vr.Body.String()
hasmore = len(links) >= golink.PAGE_SIZE
}
success = true
} else {
errorMsgs = "参数错误"
}
r := map[string]interface{}{
"success": success,
"errors": errorMsgs,
"html": html,
"hasmore": hasmore,
}
return ctx.Json(r)
}
func (this *baseController) Prepare() {
this.options = models.GetOptions()
this.right = "right.html"
this.Data["options"] = this.options
this.Data["latestblog"] = models.GetLatestBlog()
this.Data["hotblog"] = models.GetHotBlog()
this.Data["hidejs"] = `<!--[if lt IE 9]>
<script src="/views/double/js/modernizr.js"></script>
<![endif]-->`
var (
pagesize int
err error
page int
)
if page, err = strconv.Atoi(this.Ctx.Input.Param(":page")); err != nil || page < 1 {
page = 1
}
if pagesize, err = strconv.Atoi(this.getOption("pagesize")); err != nil || pagesize < 1 {
pagesize = 10
}
this.page = page
this.pagesize = pagesize
}
// Split a version into parts.
// "1.2.3-beta.2" -> []int{1, 2, 3}, []interface{}{"beta", 2}
func versionParts(v string) ([]int, []interface{}) {
if strings.HasPrefix(v, "v") || strings.HasPrefix(v, "V") {
// Strip initial 'v' or 'V' prefix if present.
v = v[1:]
}
parts := strings.SplitN(v, "+", 2)
parts = strings.SplitN(parts[0], "-", 2)
fields := strings.Split(parts[0], ".")
release := make([]int, len(fields))
for i, s := range fields {
v, _ := strconv.Atoi(s)
release[i] = v
}
var prerelease []interface{}
if len(parts) > 1 {
fields = strings.Split(parts[1], ".")
prerelease = make([]interface{}, len(fields))
for i, s := range fields {
v, err := strconv.Atoi(s)
if err == nil {
prerelease[i] = v
} else {
prerelease[i] = s
}
}
}
return release, prerelease
}
func onRequest(w http.ResponseWriter, req *http.Request) {
req.ParseForm()
f := &Frame{xrange, yrange}
{
v, err := strconv.ParseFloat(req.FormValue("xr"), 64)
if err == nil {
f.xrange = v
}
v, err = strconv.ParseFloat(req.FormValue("yr"), 64)
if err == nil {
f.yrange = v
}
}
i := &Image{width, height}
{
v, err := strconv.Atoi(req.FormValue("w"))
if err == nil {
i.width = v
}
v, err = strconv.Atoi(req.FormValue("h"))
if err == nil {
i.height = v
}
}
run(w, f, i)
}
// ParsePage reads "page" and "page_size" from a set of parameters and
// parses them into offset and limit values.
//
// It assumes that the params will be coming from a set of query
// parameters, and that the page and page_size values will be of type
// []string, since that's the default for query parameters. It will
// simply read the first value from each slice, ignoring extra values.
func ParsePage(params objx.Map, defaultPageSize int) (offset, limit int, err error) {
limit = defaultPageSize
sizeVal, sizeOk := params["page_size"]
pageVal, pageOk := params["page"]
if sizeOk {
sizeSlice := sizeVal.([]string)
sizeStr := sizeSlice[0]
var pageSize int
pageSize, err = strconv.Atoi(sizeStr)
if err != nil {
return
}
limit = pageSize
}
if pageOk {
pageSlice := pageVal.([]string)
pageStr := pageSlice[0]
var page int
page, err = strconv.Atoi(pageStr)
if err != nil {
return
}
offset = (page - 1) * limit
}
return
}
func main() {
flag.Parse()
b, err := parseFile(fmt.Sprintf("%s/%s.txt", *dir, *month))
if err != nil {
log.Fatal(err)
}
fmt.Println("Total:", b.Total)
fmt.Println("Remaining:", b.Remaining)
mon := *month
year, err := strconv.Atoi(mon[0:4])
if err != nil {
log.Fatal(err)
}
m, err := strconv.Atoi(mon[4:6])
if err != nil {
log.Fatal(err)
}
rpd := b.Remaining / float64(daysIn(time.Month(m), year)-time.Now().Day())
fmt.Printf("Remaining/day: %.2f\n", rpd)
top := map[string]float64{}
for _, t := range b.Transactions {
top[t.Name] += t.Cost
}
fmt.Println("Top costs:")
pl := sortMapByValue(top)
for _, p := range pl {
fmt.Printf("\t%s: %.2f\n", p.Key, p.Value)
}
}
// Takes care of dropping privileges to the desired user
func changeUser(u string) {
if u == "" {
return
}
userent, err := utils.UserLookup(u)
if err != nil {
log.Fatalf("Unable to find user %v: %v", u, err)
}
uid, err := strconv.Atoi(userent.Uid)
if err != nil {
log.Fatalf("Invalid uid: %v", userent.Uid)
}
gid, err := strconv.Atoi(userent.Gid)
if err != nil {
log.Fatalf("Invalid gid: %v", userent.Gid)
}
if err := syscall.Setgid(gid); err != nil {
log.Fatalf("setgid failed: %v", err)
}
if err := syscall.Setuid(uid); err != nil {
log.Fatalf("setuid failed: %v", err)
}
}
func (t *SimpleChaincode) init(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var A, B string // Entities
var Aval, Bval int // Asset holdings
var err error
if len(args) != 4 {
return nil, errors.New("Incorrect number of arguments. Expecting 4")
}
// Initialize the chaincode
A = args[0]
Aval, err = strconv.Atoi(args[1])
if err != nil {
return nil, errors.New("Expecting integer value for asset holding")
}
B = args[2]
Bval, err = strconv.Atoi(args[3])
if err != nil {
return nil, errors.New("Expecting integer value for asset holding")
}
fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval)
// Write the state to the ledger
err = stub.PutState(A, []byte(strconv.Itoa(Aval)))
if err != nil {
return nil, err
}
err = stub.PutState(B, []byte(strconv.Itoa(Bval)))
if err != nil {
return nil, err
}
return nil, nil
}
func CreateBlog(rw http.ResponseWriter, r *http.Request, enc encoding.Encoder, dtx *apicontext.DataContext) string {
var b blog_model.Blog
var err error
b.Title = r.FormValue("title")
b.Slug = r.FormValue("slug")
b.Text = r.FormValue("text")
b.PublishedDate, err = time.Parse(timeFormat, r.FormValue("publishedDate"))
b.UserID, err = strconv.Atoi(r.FormValue("userID"))
b.MetaTitle = r.FormValue("metaTitle")
b.MetaDescription = r.FormValue("metaDescription")
b.Keywords = r.FormValue("keywords")
b.Active, err = strconv.ParseBool(r.FormValue("active"))
categoryIDs := r.Form["categoryID"]
for _, v := range categoryIDs {
var bc blog_model.BlogCategory
bc.Category.ID, err = strconv.Atoi(v)
b.BlogCategories = append(b.BlogCategories, bc)
}
err = b.Create(dtx)
if err != nil {
apierror.GenerateError("Trouble creating blog", err, rw, r)
}
return encoding.Must(enc.Encode(b))
}