Ejemplo n.º 1
0
func saveUpgradeData(opts *Upgradeable, ulog string, duration time.Duration) error {
	log.Debugf("%s in (%s)\n%s",
		cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
		cmd.Colorfy(duration.String(), "green", "", "bold"),
		cmd.Colorfy(ulog, "yellow", "", ""))
	return nil
}
Ejemplo n.º 2
0
func (c *Client) ImageSetMembers(imageset *ImageSet, timeout time.Duration) (result []*Image, err error) {
	chImages := make(chan *Image)

	for _, member := range imageset.Members {
		log.Println(len(imageset.Members), "images to get:", member.ID, c)
		go func(url string) {
			image, err := c.Image(url)
			if err != nil {
				return
			}
			chImages <- image
		}(member.ID)
	}

	images := []*Image{}

	for {
		select {
		case image := <-chImages:
			log.Println("Received:", image.ID)
			images = append(images, image)
			if len(images) == len(imageset.Members) {
				return images, nil
			}
		case <-time.After(timeout):
			if timeout > time.Duration(0) {
				return nil, fmt.Errorf("Image retrieval timed out after %sms", timeout.String())
			}
		}
	}

}
Ejemplo n.º 3
0
Archivo: apps.go Proyecto: gmelika/rack
func (c *Client) StreamAppLogs(app, filter string, follow bool, since time.Duration, output io.WriteCloser) error {
	return c.Stream(fmt.Sprintf("/apps/%s/logs", app), map[string]string{
		"Filter": filter,
		"Follow": fmt.Sprintf("%t", follow),
		"Since":  since.String(),
	}, nil, output)
}
Ejemplo n.º 4
0
// StreamRackLogs streams the logs for a Rack
func (c *Client) StreamRackLogs(filter string, follow bool, since time.Duration, output io.WriteCloser) error {
	return c.Stream("/system/logs", map[string]string{
		"Filter": filter,
		"Follow": fmt.Sprintf("%t", follow),
		"Since":  since.String(),
	}, nil, output)
}
Ejemplo n.º 5
0
// SetDuration adds or modifies the configuration for a given duration at a
// specific key.
func (c *Config) SetDuration(key string, value time.Duration) {
	c.mu.RLock()
	{
		c.m[key] = value.String()
	}
	c.mu.RUnlock()
}
Ejemplo n.º 6
0
func saveDeployData(opts *DeployOpts, imageId, dlog string, duration time.Duration, deployError error) error {
	log.Debugf("%s in (%s)\n%s",
		cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
		cmd.Colorfy(duration.String(), "green", "", "bold"),
		cmd.Colorfy(dlog, "yellow", "", ""))
	//if there are deployments to track as follows in outputs: {} then do it here.
	//Riak: code to save the status of a deploy (created.)
	// deploy :
	//     name:
	//     status:

	/*deploy := DeployData {
		App:       opts.App.Name,
		Timestamp: time.Now(),
		Duration:  duration,
		Commit:    opts.Commit,
		Image:     imageId,
		Log:       log,
	}
	if opts.Commit != "" {
		deploy.Origin = "git"
	} else if opts.Image != "" {
		deploy.Origin = "rollback"
	} else {
		deploy.Origin = "app-deploy"
	}
	if deployError != nil {
		deploy.Error = deployError.Error()
	}
	return db.Store(compid or assmid, &struct)
	*/
	return nil
}
Ejemplo n.º 7
0
func saveLifecycleData(li *LifecycleOpts, llog string, elapsed time.Duration) error {
	log.Debugf("%s in (%s)\n%s",
		cmd.Colorfy(li.B.GetFullName(), "cyan", "", "bold"),
		cmd.Colorfy(elapsed.String(), "green", "", "bold"),
		cmd.Colorfy(llog, "yellow", "", ""))
	return nil
}
Ejemplo n.º 8
0
// SendReadTimeout instructs the peer to simulate a read timeout. It then waits
// for acknowledgement of the timeout, buffering any packets received since
// then. The packets are then returned.
func (p *packetAdaptor) SendReadTimeout(d time.Duration) ([][]byte, error) {
	p.log("Simulating read timeout: "+d.String(), nil)

	payload := make([]byte, 1+8)
	payload[0] = opcodeTimeout
	binary.BigEndian.PutUint64(payload[1:], uint64(d.Nanoseconds()))
	if _, err := p.Conn.Write(payload); err != nil {
		return nil, err
	}

	var packets [][]byte
	for {
		opcode, err := p.readOpcode()
		if err != nil {
			return nil, err
		}
		switch opcode {
		case opcodeTimeoutAck:
			p.log("Received timeout ACK", nil)
			// Done! Return the packets buffered and continue.
			return packets, nil
		case opcodePacket:
			// Buffer the packet for the caller to process.
			packet, err := p.readPacketBody()
			if err != nil {
				return nil, err
			}
			p.log("Simulating dropped packet", packet)
			packets = append(packets, packet)
		default:
			return nil, fmt.Errorf("unexpected opcode '%d'", opcode)
		}
	}
}
Ejemplo n.º 9
0
// TODO: Place at the bottom of the content instead of at the bottom of the window
func AddFooter(page *onthefly.Page, footerText, footerTextColor, footerColor string, elapsed time.Duration) (*onthefly.Tag, error) {
	body, err := page.GetTag("body")
	if err != nil {
		return nil, err
	}
	div := body.AddNewTag("div")
	div.AddAttrib("id", "notice")
	div.AddStyle("position", "fixed")
	div.AddStyle("bottom", "0")
	div.AddStyle("left", "0")
	div.AddStyle("width", "100%")
	div.AddStyle("display", "block")
	div.AddStyle("padding", "0")
	div.AddStyle("margin", "0")
	div.AddStyle("background-color", footerColor)
	div.AddStyle("font-size", "0.6em")
	div.AddStyle("text-align", "right")
	div.AddStyle("box-shadow", "1px -2px 3px rgba(0,0,0, .5)")

	innerdiv := div.AddNewTag("div")
	innerdiv.AddAttrib("id", "innernotice")
	innerdiv.AddStyle("padding", "0 2em 0 0")
	innerdiv.AddStyle("margin", "0")
	innerdiv.AddStyle("color", footerTextColor)
	innerdiv.AddContent("Generated in " + elapsed.String() + " | " + footerText)

	return div, nil
}
Ejemplo n.º 10
0
func client(wg *sync.WaitGroup, host string, port, len int, duration time.Duration, chStat chan int) {
	defer func() {
		if r := recover(); r != nil {
			log.Printf("error: %s", r)
		}
		log.Printf("disconnected")
		wg.Done()
	}()
	log.Printf("connecting to %s:%d, len %d, duration %s", host, port, len, duration.String())
	conn, err := utp.DialTimeout(fmt.Sprintf("%s:%d", host, port), time.Second)
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	log.Printf("connected")
	buf := bytes.Repeat([]byte("H"), len)
	ts := time.Now()
	for time.Since(ts) < duration {
		n, err := conn.Write(buf)
		if err != nil {
			if err == io.EOF {
				break
			}
			panic(err)
		}
		chStat <- n
	}
}
Ejemplo n.º 11
0
// RegisterServiceLocal registers the service as running on the current node.
func RegisterServiceLocal(
	service string, instanceID string, target string,
	ttl time.Duration) (err error) {
	consul := config.GetConsulClient()
	agent := consul.Agent()

	// Parse target into address + port.
	addressSplit := strings.Split(target, ":")
	if len(addressSplit) != 2 {
		return fmt.Errorf("Invalid address")
	}
	port, err := strconv.Atoi(addressSplit[1])
	if err != nil {
		return fmt.Errorf("Invalid address")
	}
	address := addressSplit[0]
	return agent.ServiceRegister(&consulapi.AgentServiceRegistration{
		Name:    service,
		ID:      instanceID,
		Address: address,
		Port:    port,
		Check: &consulapi.AgentServiceCheck{
			TTL:    ttl.String(),
			Status: "passing",
		},
	})
}
Ejemplo n.º 12
0
// NewIngestionProcess creates a Process for ingesting data.
func NewIngestionProcess(git *gitinfo.GitInfo, tileDir, datasetName string, ri ingester.ResultIngester, config map[string]string, every time.Duration, nCommits int, minDuration time.Duration, statusDir, metricName string) ProcessStarter {
	return func() {
		i, err := ingester.NewIngester(git, tileDir, datasetName, ri, nCommits, minDuration, config, statusDir, metricName)
		if err != nil {
			glog.Fatalf("Failed to create Ingester: %s", err)
		}

		glog.Infof("Starting %s ingester. Run every %s.", datasetName, every.String())

		// oneStep is a single round of ingestion.
		oneStep := func() {
			glog.Infof("Running ingester: %s", datasetName)
			err := i.Update()
			if err != nil {
				glog.Error(err)
			}
			glog.Infof("Finished running ingester: %s", datasetName)
		}

		// Start the ingester.
		go func() {
			oneStep()
			for _ = range time.Tick(every) {
				oneStep()
			}
		}()
	}
}
Ejemplo n.º 13
0
func bench(target string) {
	fmt.Println("begin bench to: " + target + " ...")

	succ := 0
	fail := 0
	var t time.Duration = 0
	for i := 0; i < 10 || t.Seconds() < 30; i++ {
		start := time.Now()
		resp, err := net.NewHttpGet(target)
		if err == nil {
			defer resp.Close()
			_, err := resp.ReadAll()
			if err == nil {
				succ++
				end := time.Now()
				t += end.Sub(start)
				continue
			}
		}

		fail++
	}

	fmt.Printf("succ: %d\n", succ)
	if succ > 0 {
		fmt.Println("used: " + t.String())
		fmt.Println("avg:  " + time.Duration(int64(t)/int64(succ)).String())
	}

	fmt.Printf("fail: %d\n", fail)
}
Ejemplo n.º 14
0
// Helper function for creating an alert on low throughput, aka deadman's switch.
//
// - Threshold -- trigger alert if throughput drops below threshold in points/interval.
// - Interval -- how often to check the throughput.
// - Expressions -- optional list of expressions to also evaluate. Useful for time of day alerting.
//
// Example:
//    var data = stream.from()...
//    // Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
//    data.deadman(100.0, 10s)
//    //Do normal processing of data
//    data....
//
// The above is equivalent to this
// Example:
//    var data = stream.from()...
//    // Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
//    data.stats(10s)
//          .derivative('collected')
//              .unit(10s)
//              .nonNegative()
//          .alert()
//              .id('node \'stream0\' in task \'{{ .TaskName }}\'')
//              .message('{{ .ID }} is {{ if eq .Level "OK" }}alive{{ else }}dead{{ end }}: {{ index .Fields "collected" | printf "%0.3f" }} points/10s.')
//              .crit(lamdba: "collected" <= 100.0)
//    //Do normal processing of data
//    data....
//
// The `id` and `message` alert properties can be configured globally via the 'deadman' configuration section.
//
// Since the AlertNode is the last piece it can be further modified as normal.
// Example:
//    var data = stream.from()...
//    // Trigger critical alert if the throughput drops below 100 points per 1s and checked every 10s.
//    data.deadman(100.0, 10s).slack().channel('#dead_tasks')
//    //Do normal processing of data
//    data....
//
// You can specify additional lambda expressions to further constrain when the deadman's switch is triggered.
// Example:
//    var data = stream.from()...
//    // Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
//    // Only trigger the alert if the time of day is between 8am-5pm.
//    data.deadman(100.0, 10s, lambda: hour("time") >= 8 AND hour("time") <= 17)
//    //Do normal processing of data
//    data....
//
func (n *node) Deadman(threshold float64, interval time.Duration, expr ...tick.Node) *AlertNode {
	dn := n.Stats(interval).
		Derivative("emitted").NonNegative()
	dn.Unit = interval

	an := dn.Alert()
	critExpr := &tick.BinaryNode{
		Operator: tick.TokenLessEqual,
		Left: &tick.ReferenceNode{
			Reference: "emitted",
		},
		Right: &tick.NumberNode{
			IsFloat: true,
			Float64: threshold,
		},
	}
	// Add any additional expressions
	for _, e := range expr {
		critExpr = &tick.BinaryNode{
			Operator: tick.TokenAnd,
			Left:     critExpr,
			Right:    e,
		}
	}
	an.Crit = critExpr
	// Replace NODE_NAME with actual name of the node in the Id.
	an.Id = strings.Replace(n.pipeline().deadman.Id(), nodeNameMarker, n.Name(), 1)
	// Set the message on the alert node.
	an.Message = strings.Replace(n.pipeline().deadman.Message(), intervalMarker, interval.String(), 1)
	return an
}
Ejemplo n.º 15
0
// Send will update the given body with the paramters expected by a Pandora server
// and return the Mid generated by the server or an error.
func (mb *Mailbox) Send(from, to string, delay time.Duration, body url.Values) (string, error) {
	var msg pandora.Message
	msg.Empty(body)
	msg.SetSender(from)
	msg.SetReceiver(to)
	msg.SetClientTime(time.Now())
	msg.Set("delay", delay.String())

	res, err := mb.Client.PostForm(mb.BaseUrl+"/send", body)
	if err != nil {
		return "", err
	}
	defer res.Body.Close()

	if res.StatusCode != http.StatusOK {
		return "", fmt.Errorf("invalid status code: %v", res.StatusCode)
	}

	buf, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return "", err
	}

	values, err := url.ParseQuery(string(buf))
	if err != nil {
		return "", err
	}

	if len(values.Get("error")) > 0 {
		return "", errors.New(values.Get("error"))
	}

	return values.Get("mid"), nil
}
Ejemplo n.º 16
0
// Fetch asks for the server for a message
func (mb *Mailbox) Fetch(from string, lockFor time.Duration) (url.Values, error) {
	// now, try to consume the message
	msgToFetch := make(url.Values)
	msgToFetch.Set(pandora.KeyReceiver, from)
	msgToFetch.Set(pandora.KeyLeaseTime, lockFor.String())

	res, err := mb.Client.PostForm(mb.BaseUrl+"/fetch", msgToFetch)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	if res.StatusCode == http.StatusNoContent {
		return nil, ErrNoData
	}

	if res.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("invalid status code: %v", res.StatusCode)
	}

	buf, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}
	respValues, err := url.ParseQuery(string(buf))
	if err != nil {
		return nil, err
	}
	if len(respValues.Get("mid")) == 0 {
		return nil, fmt.Errorf("mid empty")
	}
	return respValues, nil
}
Ejemplo n.º 17
0
func saveDeployData(opts *StateOpts, dlog string, duration time.Duration) error {
	log.Debugf("%s in (%s)\n%s",
		cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
		cmd.Colorfy(duration.String(), "green", "", "bold"),
		cmd.Colorfy(dlog, "yellow", "", ""))
	return nil
}
Ejemplo n.º 18
0
func saveStateData(opts *StateChangeOpts, slog string, duration time.Duration, changeError error) error {
	log.Debugf("%s in (%s)\n%s",
		cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
		cmd.Colorfy(duration.String(), "green", "", "bold"),
		cmd.Colorfy(slog, "yellow", "", ""))

	if opts.B.Level == provision.BoxSome && opts.B.Repo.IsEnabled() {
		hookId, err := repository.Manager(opts.B.Repo.GetSource()).CreateHook(opts.B.Repo)
		if err != nil {
			return nil
		}

		comp, err := NewComponent(opts.B.Id)
		if err != nil {
			return err
		}

		if err = comp.setDeployData(DeployData{
			Timestamp: time.Now(),
			Duration:  duration,
			HookId:    hookId,
		}); err != nil {
			return err
		}
	}
	return nil
}
Ejemplo n.º 19
0
func respondSelected(w http.ResponseWriter, records interface{}, duration time.Duration) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"records":  records,
		"duration": duration.String(),
	})
}
Ejemplo n.º 20
0
func calc_Duration_Done_All(Direction_id int) (string, string) {
	//
	var delta_work time.Duration
	var delta_all time.Duration

	tasks_work := GetTasks(Direction_id, true)
	for _, val := range tasks_work {
		var delta time.Duration
		var err error

		if val.IsDone {
			delta, err = time.ParseDuration(val.Duration)
			if err != nil {
				fmt.Printf("%v\n", err)
			}
		} else {
			delta, err = time.ParseDuration(val.Work_time)
			if err != nil {
				fmt.Printf("%v\n", err)
			}
		}
		delta_work += delta
	}

	tasks_all := GetTasks(Direction_id, false)
	for _, val := range tasks_all {
		delta, err := time.ParseDuration(val.Duration)
		if err != nil {
			fmt.Printf("%v\n", err)
		}
		delta_all += delta
	}
	return pretty_duration(delta_work.String()), pretty_duration(delta_all.String())
}
Ejemplo n.º 21
0
// Execute ... executes a command and returns the output
// 	command:	the command you wish to execute
//	args:		an array of argument to pass to the command
// 	timeout:	a time.Duration to wait before killing off the command
func Execute(timeout time.Duration, command string, args ...string) ([]byte, error) {
	var b bytes.Buffer

	if timeout.Seconds() <= 0 {
		timeout = time.Duration(10) * time.Second
	}

	glog.V(4).Infof("Attempting to execute the command: %s, args: [%s], timeout: %s", command,
		strings.Join(args, ","), timeout.String())

	cmd := exec.Command(command, args...)
	cmd.Stdout = &b
	cmd.Stderr = &b
	cmd.Start()
	timer := time.AfterFunc(timeout, func() {
		err := cmd.Process.Kill()
		if err != nil {
			panic(err)
		}
	})
	err := cmd.Wait()
	if err != nil {
		glog.Errorf("Failed to execute the command, error: %s", err)
		return []byte{}, err
	}
	// stop the timer
	timer.Stop()

	glog.V(5).Infof("Command output: %s", b.String())

	return b.Bytes(), nil
}
Ejemplo n.º 22
0
func (*PingCommand) Run(a subcommands.Application, args []string) int {
	start := time.Now()
	mgo := NewFromConfigFile("mgo.conf", true)

	pings := make([]time.Duration, 0)
	mgo.Discover(func(message Message) {
		ping := time.Since(start)
		pings = append(pings, ping)
		fmt.Printf("%-40s time=%s\n", message.Body.Senderid, ping.String())
	})

	var min, max, sum time.Duration
	min = pings[0]
	for _, ping := range pings {
		sum += ping
		if ping > max {
			max = ping
		}
		if ping < min {
			min = ping
		}
	}

	mean := time.Duration(int64(sum) / int64(len(pings)))
	fmt.Println()
	fmt.Println("--- ping statistics ---")
	fmt.Printf("%d replies max: %s min: %s avg: %s\n",
		len(pings), max.String(), min.String(), mean.String())
	return 0
}
Ejemplo n.º 23
0
func saveBootData(boot *BootOpts, blog string, elapsed time.Duration) error {
	log.Debugf("%s in (%s)\n%s",
		cmd.Colorfy(boot.B.GetFullName(), "cyan", "", "bold"),
		cmd.Colorfy(elapsed.String(), "green", "", "bold"),
		cmd.Colorfy(blog, "yellow", "", ""))
	return nil
}
Ejemplo n.º 24
0
// doShareUploadURL uploads files to the target.
func doShareUploadURL(objectURL string, isRecursive bool, expiry time.Duration, contentType string) *probe.Error {
	clnt, err := newClient(objectURL)
	if err != nil {
		return err.Trace(objectURL)
	}

	// Generate pre-signed access info.
	uploadInfo, err := clnt.ShareUpload(isRecursive, expiry, contentType)
	if err != nil {
		return err.Trace(objectURL, "expiry="+expiry.String(), "contentType="+contentType)
	}

	// Generate curl command.
	curlCmd := makeCurlCmd(objectURL, isRecursive, uploadInfo)

	printMsg(shareMesssage{
		ObjectURL:   objectURL,
		ShareURL:    curlCmd,
		TimeLeft:    expiry,
		ContentType: contentType,
	})

	// save shared URL to disk.
	return saveSharedURL(objectURL, curlCmd, expiry, contentType)
}
Ejemplo n.º 25
0
func (s *Server) DoBatchRecording(name string, past time.Duration) (id string, err error) {
	v := url.Values{}
	v.Add("type", "batch")
	v.Add("name", name)
	v.Add("past", past.String())
	r, err := http.Post(s.URL()+"/record?"+v.Encode(), "", nil)
	if err != nil {
		return
	}
	defer r.Body.Close()
	if r.StatusCode != http.StatusOK {
		err = fmt.Errorf("unexpected status code got %d exp %d", r.StatusCode, http.StatusOK)
		return
	}

	// Decode valid response
	type resp struct {
		RecordingID string `json:"RecordingID"`
		Error       string `json:"Error"`
	}
	rp := resp{}
	d := json.NewDecoder(r.Body)
	d.Decode(&rp)
	if rp.Error != "" {
		err = errors.New(rp.Error)
		return
	}
	id = rp.RecordingID
	v = url.Values{}
	v.Add("id", id)
	_, err = s.HTTPGet(s.URL() + "/record?" + v.Encode())
	return
}
Ejemplo n.º 26
0
func respondDeleted(w http.ResponseWriter, n int, duration time.Duration) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"deleted":  n,
		"duration": duration.String(),
	})
}
Ejemplo n.º 27
0
func Get_Statistic() []Statistic {
	//
	var result []Statistic
	for i := 0; i < 5; i += 1 {
		//
		map_direct_duration := make(map[string]time.Duration)
		dt_now := time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), 0, 0, 0, 0, time.UTC)

		//dur_day, _ := time.ParseDuration(fmt.Sprintf("%dh", 24 * i))
		dt_now = dt_now.AddDate(0, 0, -1*i)
		//fmt.Printf("date:%v\n", dt_now)

		for _, val := range Task_map {
			DateDead, err := time.Parse("2006-01-02 15:04:05", val.DateDead)
			if err != nil {
				fmt.Printf("%v\n", err)
			}
			if DateDead.Unix() > dt_now.Unix() && DateDead.Unix() < dt_now.AddDate(0, 0, 1).Unix() {
				//fmt.Printf("DateDead:%v\n", DateDead)
				if val.IsDone {
					dur_task, err := time.ParseDuration(val.Duration)
					if err != nil {
						fmt.Printf("%v\n", err)
					}
					map_direct_duration[val.Direction] += dur_task
				} else {
					dur_task, err := time.ParseDuration(val.Work_time)
					if err != nil {
						fmt.Printf("%v\n", err)
					}
					if dur_task.Seconds() > 0 {
						map_direct_duration[val.Direction] += dur_task
					}
				}
			}
		}

		var list_info []Info_Direction
		var sum time.Duration

		for name, val := range map_direct_duration {
			var info Info_Direction
			info.Name = name
			info.Duration = pretty_duration(val.String())
			list_info = append(list_info, info)
			sum += val
		}

		var sts Statistic
		sts.Date = print_date(dt_now)
		sts.List_Info_Direction = list_info
		sts.Sum_Duration = pretty_duration(sum.String())
		//fmt.Printf("Statistic:%v\n", sts)
		if len(list_info) > 0 {
			result = append(result, sts)
		}
	}
	return result
}
Ejemplo n.º 28
0
func renderMarkdown(c *gin.Context, currentText string, title string, versions []versionsInfo, AdminKey string, totalTime time.Duration, encrypted bool, noprompt bool, locked bool, recentlyEdited []string) {
	originalText := currentText
	CodeType := getCodeType(title)
	if CodeType == "markdown" {
		CodeType = ""
	}
	r, _ := regexp.Compile("\\[\\[(.*?)\\]\\]")
	for _, s := range r.FindAllString(currentText, -1) {
		currentText = strings.Replace(currentText, s, "["+s[2:len(s)-2]+"](/"+s[2:len(s)-2]+"/view)", 1)
	}
	unsafe := blackfriday.MarkdownCommon([]byte(currentText))
	pClean := bluemonday.UGCPolicy()
	pClean.AllowElements("img")
	pClean.AllowAttrs("alt").OnElements("img")
	pClean.AllowAttrs("src").OnElements("img")
	pClean.AllowAttrs("class").OnElements("a")
	pClean.AllowAttrs("href").OnElements("a")
	pClean.AllowAttrs("id").OnElements("a")
	pClean.AllowDataURIImages()
	html := pClean.SanitizeBytes(unsafe)
	html2 := string(html)
	r, _ = regexp.Compile("\\$\\$(.*?)\\$\\$")
	for _, s := range r.FindAllString(html2, -1) {
		html2 = strings.Replace(html2, s, "<span class='texp' data-expr='"+s[2:len(s)-2]+"'></span>", 1)
	}
	r, _ = regexp.Compile("\\$(.*?)\\$")
	for _, s := range r.FindAllString(html2, -1) {
		html2 = strings.Replace(html2, s, "<span class='texi' data-expr='"+s[1:len(s)-1]+"'></span>", 1)
	}

	html2 = strings.Replace(html2, "&amp;#36;", "&#36;", -1)
	html2 = strings.Replace(html2, "&amp;#91;", "&#91;", -1)
	html2 = strings.Replace(html2, "&amp;#93;", "&#93;", -1)
	html2 = strings.Replace(html2, "&amp35;", "&#35;", -1)
	totalTimeString := totalTime.String()
	if totalTime.Seconds() < 1 {
		totalTimeString = "< 1 s"
	}
	if encrypted {
		CodeType = "asciiarmor"
	}
	c.HTML(http.StatusOK, "view.tmpl", gin.H{
		"Title":             title,
		"WikiName":          RuntimeArgs.WikiName,
		"Body":              template.HTML([]byte(html2)),
		"CurrentText":       originalText,
		"Versions":          versions,
		"TotalTime":         totalTimeString,
		"AdminKey":          AdminKey,
		"Encrypted":         encrypted,
		"Locked":            locked,
		"Prompt":            noprompt,
		"LockedOrEncrypted": locked || encrypted,
		"Coding":            len(CodeType) > 0,
		"CodeType":          CodeType,
		"RecentlyEdited":    recentlyEdited,
	})

}
Ejemplo n.º 29
0
func (s JSONStruct) SetDuration(dotPath string, value time.Duration) error {
	parent, lastKey, err := s.findParent(dotPath)
	if err != nil {
		return err
	}
	parent[lastKey] = value.String()
	return nil
}
Ejemplo n.º 30
0
func (ur UptimeReports) totalMonthlyDowntime() string {
	var sum time.Duration
	for _, u := range ur {
		sum += time.Duration(u.MonthAgo.Totaldown)
	}
	sum = sum * time.Second
	return sum.String()
}