hunk.code_window: func (scheduler *TestScheduler) Run() {
   	l4g.Debug("Scheduler %v: Started", scheduler.name)
   	defer func(){
   		l4g.Debug("Scheduler %v: Finished", scheduler.name)
   		scheduler.stopped <- true
   	}()
  
hunk.labels: keep keep keep keep replace keep keep keep keep
hunk.after_edit: 	defer func() {
  
hunk.file_path: jobs/testscheduler.go
hunk.type: replace
file: // Copyright 2012 The Go Authors.  All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  // Package client implements a basic appfs client.
  package client
  
  import (
  	"bytes"
  	"encoding/json"
  	"fmt"
  	"io"
  	"io/ioutil"
  	"net/http"
  	"strings"
  	"time"
  
  	"github.com/mattermost/rsc/appfs/proto"
  )
  
  type Client struct {
  	Host     string
  	User string
  	Password string
  }
  
  func (c *Client) url(op, path string) string {
  	scheme := "https"
  	if strings.HasPrefix(c.Host, "localhost:") {
  		scheme = "http"
  	}
  	if strings.HasSuffix(op, "/") && strings.HasPrefix(path, "/") {
  		path = path[1:]
  	}
  	return scheme + "://"+ c.User + ":" + c.Password + "@" + c.Host + op + path
  }
  
  func (c *Client) do(u string) error {
  	_, err := c.get(u)
  	return err
  }
  
  func (c *Client) get(u string) ([]byte, error) {
  	tries := 0
  	for {
  		r, err := http.Get(u)
  		if err != nil {
  			return nil, err
  		}
  		defer r.Body.Close()
  		data, err := ioutil.ReadAll(r.Body)
  		if err != nil {
  			return nil, err
  		}
  		if r.StatusCode != 200 {
  			if r.StatusCode == 500 {
  				if tries++; tries < 3 {
  					fmt.Printf("%s %s; sleeping\n", r.Status, data)
  					time.Sleep(5*time.Second)
  					continue
  				}
  			}
  			return nil, fmt.Errorf("%s %s", r.Status, data)
  		}
  		return data, nil
  	}
  	panic("unreachable")
  }
  
  func (c *Client) post(u string, data []byte) ([]byte, error) {
  	tries := 0
  	for {
  		r, err := http.Post(u, proto.PostContentType, bytes.NewBuffer(data))
  		if err != nil {
  			return nil, err
  		}
  		defer r.Body.Close()
  		rdata, err := ioutil.ReadAll(r.Body)
  		if err != nil {
  			return nil, err
  		}
  		if r.StatusCode != 200 {
  			if r.StatusCode == 500 {
  				if tries++; tries < 3 {
  					fmt.Printf("%s %s; sleeping\n", r.Status, rdata)
  					time.Sleep(5*time.Second)
  					continue
  				}
  			}
  			return nil, fmt.Errorf("%s %s", r.Status, rdata)
  		}
  		return rdata, nil
  	}
  	panic("unreachable")
  }
  
  func (c *Client) Create(path string, isdir bool) error {
  	u := c.url(proto.CreateURL, path)
  	if isdir {
  		u += "?dir=1"
  	}
  	return c.do(u)
  }
  
  func (c *Client) Read(path string) ([]byte, error) {
  	return c.get(c.url(proto.ReadURL, path))
  }
  
  func (c *Client) Write(path string, data []byte) error {
  	u := c.url(proto.WriteURL, path)
  	_, err := c.post(u, data)
  	return err
  }
  
  func (c *Client) Mkfs() error {
  	return c.do(c.url(proto.MkfsURL, ""))
  }
  
  func (c *Client) Stat(path string) (*proto.FileInfo, error) {
  	data, err := c.get(c.url(proto.StatURL, path))
  	if err != nil {
  		return nil, err
  	}
  	var fi proto.FileInfo
  	if err := json.Unmarshal(data, &fi); err != nil {
  		return nil, err
  	}
  	return &fi, nil
  }
  
  func (c *Client) ReadDir(path string) ([]*proto.FileInfo, error) {
  	data, err := c.Read(path)
  	if err != nil {
  		return nil, err
  	}
  	dec := json.NewDecoder(bytes.NewBuffer(data))
  	var out []*proto.FileInfo
  	for {
  		var fi proto.FileInfo
  		err := dec.Decode(&fi)
  		if err == io.EOF {
  			break
  		}
  		if err != nil {
  			return out, err
  		}
  		out = append(out, &fi)
  	}
  	return out, nil
  }
  