_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q181600
|
StrLenIn
|
test
|
func (c *Controller) StrLenIn(fieldName string, p interface{}, l ...int) string {
if p == nil {
p = ""
}
v, ok := p.(string)
if ok == false {
panic((&ValidationError{}).New(fieldName + "格式错误"))
}
length := utf8.RuneCountInString(v)
b := false
for i := 0; i < len(l); i++ {
if l[i] == length {
b = true
}
}
if b == false {
panic((&ValidationError{}).New(fieldName + "值的长度应该在" + strings.Replace(strings.Trim(fmt.Sprint(l), "[]"), " ", ",", -1) + "中"))
}
return v
}
|
go
|
{
"resource": ""
}
|
q181601
|
StrIn
|
test
|
func (c *Controller) StrIn(fieldName string, p interface{}, l ...string) string {
if p == nil {
p = ""
}
v, ok := p.(string)
if ok == false {
panic((&ValidationError{}).New(fieldName + "格式错误"))
}
b := false
for i := 0; i < len(l); i++ {
if l[i] == v {
b = true
}
}
if b == false {
panic((&ValidationError{}).New(fieldName + "值应该在" + strings.Replace(strings.Trim(fmt.Sprint(l), "[]"), " ", ",", -1) + "中"))
}
return v
}
|
go
|
{
"resource": ""
}
|
q181602
|
GetEmail
|
test
|
func (c *Controller) GetEmail(fieldName string, p interface{}) string {
if p == nil {
p = ""
}
v, ok := p.(string)
if ok == false {
panic((&ValidationError{}).New(fieldName + "格式错误"))
}
b := c.Validate.Email(v)
if b == false {
panic((&ValidationError{}).New(fieldName + "格式错误"))
}
return v
}
|
go
|
{
"resource": ""
}
|
q181603
|
MostSpecificType
|
test
|
func MostSpecificType(types []string) (string, error) {
if len(types) == 0 {
return "", errors.New("no types supplied")
}
sorted, err := SortTypes(types)
if err != nil {
return "", err
}
return sorted[len(sorted)-1], nil
}
|
go
|
{
"resource": ""
}
|
q181604
|
FullTypeHierarchy
|
test
|
func FullTypeHierarchy(highestLevelType string) []string {
var typeHierarchy []string
t := strings.Split(highestLevelType, "/")
typeToCheck := t[len(t)-1]
for {
typeHierarchy = append(typeHierarchy, typeToCheck)
parentType := ParentType(typeToCheck)
if parentType != "" {
typeToCheck = parentType
} else {
return TypeURIs(typeHierarchy)
}
}
}
|
go
|
{
"resource": ""
}
|
q181605
|
SortTypes
|
test
|
func SortTypes(types []string) ([]string, error) {
ts := &typeSorter{types: make([]string, len(types))}
copy(ts.types, types)
sort.Sort(ts)
if ts.invalid {
return types, ErrNotHierarchy
}
return ts.types, nil
}
|
go
|
{
"resource": ""
}
|
q181606
|
Delete
|
test
|
func (rs *redisStore) Delete(key string) error {
delete(rs.Values, key)
err := provider.refresh(rs)
return err
}
|
go
|
{
"resource": ""
}
|
q181607
|
Set
|
test
|
func (rp *redisProvider) Set(key string, values map[string]string) (*redisStore, error) {
rs := &redisStore{SID: key, Values: values}
err := provider.refresh(rs)
return rs, err
}
|
go
|
{
"resource": ""
}
|
q181608
|
refresh
|
test
|
func (rp *redisProvider) refresh(rs *redisStore) error {
var err error
redisPool.Exec(func(c *redis.Client) {
err = c.HMSet(rs.SID, rs.Values).Err()
if err != nil {
return
}
err = c.Expire(rs.SID, sessExpire).Err()
})
return nil
}
|
go
|
{
"resource": ""
}
|
q181609
|
Get
|
test
|
func (rp *redisProvider) Get(sid string) (*redisStore, error) {
var rs = &redisStore{}
var val map[string]string
var err error
redisPool.Exec(func(c *redis.Client) {
val, err = c.HGetAll(sid).Result()
rs.Values = val
})
return rs, err
}
|
go
|
{
"resource": ""
}
|
q181610
|
Destroy
|
test
|
func (rp *redisProvider) Destroy(sid string) error {
var err error
redisPool.Exec(func(c *redis.Client) {
err = c.Del(sid).Err()
})
return err
}
|
go
|
{
"resource": ""
}
|
q181611
|
UpExpire
|
test
|
func (rp *redisProvider) UpExpire(sid string) error {
var err error
redisPool.Exec(func(c *redis.Client) {
err = c.Expire(sid, sessExpire).Err()
})
return err
}
|
go
|
{
"resource": ""
}
|
q181612
|
Use
|
test
|
func (hs *HandlersStack) Use(h RouterHandler) {
hs.Handlers = append(hs.Handlers, h)
}
|
go
|
{
"resource": ""
}
|
q181613
|
ServeHTTP
|
test
|
func (hs *HandlersStack) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Get a context for the request from ctxPool.
c := getContext(w, r)
// Set some "good practice" default headers.
c.ResponseWriter.Header().Set("Cache-Control", "no-cache")
c.ResponseWriter.Header().Set("Content-Type", "application/json")
c.ResponseWriter.Header().Set("Connection", "keep-alive")
c.ResponseWriter.Header().Set("Vary", "Accept-Encoding")
//c.ResponseWriter.Header().Set("Access-Control-Allow-Origin", "*")
c.ResponseWriter.Header().Set("Access-Control-Allow-Headers", "X-Requested-With")
c.ResponseWriter.Header().Set("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS")
// Always recover form panics.
defer c.Recover()
// Enter the handlers stack.
c.Next()
// Respnose data
// if c.written == false {
// c.Fail(errors.New("not written"))
// }
// Put the context to ctxPool
putContext(c)
}
|
go
|
{
"resource": ""
}
|
q181614
|
Use
|
test
|
func (group *RouterGroup) Use(middleware ...RouterHandler) IRoutes {
group.Handlers = append(group.Handlers, middleware...)
return group.returnObj()
}
|
go
|
{
"resource": ""
}
|
q181615
|
Group
|
test
|
func (group *RouterGroup) Group(relativePath string, handlers ...RouterHandler) *RouterGroup {
return &RouterGroup{
Handlers: group.combineHandlers(handlers),
basePath: group.calculateAbsolutePath(relativePath),
engine: group.engine,
}
}
|
go
|
{
"resource": ""
}
|
q181616
|
Run
|
test
|
func Run() {
for _, f := range beforeRun {
f()
}
// parse command line params.
if OpenCommandLine {
flag.StringVar(&Address, "address", ":8080", "-address=:8080")
flag.BoolVar(&Production, "production", false, "-production=false")
flag.Parse()
}
log.Warnln(fmt.Sprintf("Serving %s with pid %d. Production is %t.", Address, os.Getpid(), Production))
// set default router.
Use(Routers.handlers)
// set graceful server.
srv := &graceful.Server{
ListenLimit: ListenLimit,
ConnState: func(conn net.Conn, state http.ConnState) {
// conn has a new state
},
Server: &http.Server{
Addr: Address,
Handler: defaultHandlersStack,
ReadTimeout: ReadTimeout,
WriteTimeout: WriteTimeout,
IdleTimeout: IdleTimeout,
MaxHeaderBytes: MaxHeaderBytes,
},
}
err := srv.ListenAndServe()
if err != nil {
log.Fatalln(err)
}
log.Warnln("Server stoped.")
}
|
go
|
{
"resource": ""
}
|
q181617
|
create
|
test
|
func create() *Engine {
engine := &Engine{
RouterGroup: RouterGroup{
Handlers: nil,
basePath: "/",
root: true,
},
trees: make(methodTrees, 0, 9),
}
engine.RouterGroup.engine = engine
return engine
}
|
go
|
{
"resource": ""
}
|
q181618
|
Redirect
|
test
|
func (ctx *Context) Redirect(url string, code int) {
http.Redirect(ctx.ResponseWriter, ctx.Request, url, code)
}
|
go
|
{
"resource": ""
}
|
q181619
|
Ok
|
test
|
func (ctx *Context) Ok(data interface{}) {
if ctx.written == true {
log.WithFields(log.Fields{"path": ctx.Request.URL.Path}).Warnln("Context.Success: request has been writed")
return
}
ctx.written = true
var json = jsoniter.ConfigCompatibleWithStandardLibrary
b, _ := json.Marshal(&ResFormat{Ok: true, Data: data})
ctx.ResponseWriter.WriteHeader(http.StatusOK)
ctx.ResponseWriter.Write(b)
}
|
go
|
{
"resource": ""
}
|
q181620
|
Fail
|
test
|
func (ctx *Context) Fail(err error) {
if err == nil {
log.WithFields(log.Fields{"path": ctx.Request.URL.Path}).Warnln("Context.Fail: err is nil")
ctx.ResponseWriter.WriteHeader(http.StatusInternalServerError)
ctx.ResponseWriter.Write(nil)
return
}
if ctx.written == true {
log.WithFields(log.Fields{"path": ctx.Request.URL.Path}).Warnln("Context.Fail: request has been writed")
return
}
errno := 0
errCore, ok := err.(ICoreError)
if ok == true {
errno = errCore.GetErrno()
}
ctx.written = true
if Production == false {
log.WithFields(log.Fields{"path": ctx.Request.URL.Path}).Warnln(err.Error())
} else if _, ok := err.(*ServerError); ok == true {
log.WithFields(log.Fields{"path": ctx.Request.URL.Path}).Warnln(err.Error())
}
var json = jsoniter.ConfigCompatibleWithStandardLibrary
b, _ := json.Marshal(&ResFormat{Ok: false, Message: err.Error(), Errno: errno})
coreErr, ok := err.(ICoreError)
if ok == true {
ctx.ResponseWriter.WriteHeader(coreErr.GetHTTPCode())
} else {
ctx.ResponseWriter.WriteHeader(http.StatusInternalServerError)
}
ctx.ResponseWriter.Write(b)
}
|
go
|
{
"resource": ""
}
|
q181621
|
ResStatus
|
test
|
func (ctx *Context) ResStatus(code int) (int, error) {
if ctx.written == true {
return 0, errors.New("Context.ResStatus: request has been writed")
}
ctx.written = true
ctx.ResponseWriter.WriteHeader(code)
return fmt.Fprint(ctx.ResponseWriter, http.StatusText(code))
}
|
go
|
{
"resource": ""
}
|
q181622
|
Next
|
test
|
func (ctx *Context) Next() {
// Call the next handler only if there is one and the response hasn't been written.
if !ctx.Written() && ctx.index < len(ctx.handlersStack.Handlers)-1 {
ctx.index++
ctx.handlersStack.Handlers[ctx.index](ctx)
}
}
|
go
|
{
"resource": ""
}
|
q181623
|
GetSession
|
test
|
func (ctx *Context) GetSession() IStore {
store := ctx.Data["session"]
if store == nil {
return nil
}
st, ok := store.(IStore)
if ok == false {
return nil
}
return st
}
|
go
|
{
"resource": ""
}
|
q181624
|
GetBodyJSON
|
test
|
func (ctx *Context) GetBodyJSON() {
var reqJSON map[string]interface{}
body, _ := ioutil.ReadAll(ctx.Request.Body)
defer ctx.Request.Body.Close()
cType := ctx.Request.Header.Get("Content-Type")
a := strings.Split(cType, ";")
if a[0] == "application/x-www-form-urlencoded" {
reqJSON = make(map[string]interface{})
reqStr := string(body)
reqArr := strings.Split(reqStr, "&")
for _, v := range reqArr {
param := strings.Split(v, "=")
reqJSON[param[0]], _ = url.QueryUnescape(param[1])
}
} else {
json.Unmarshal(body, &reqJSON)
}
ctx.BodyJSON = reqJSON
}
|
go
|
{
"resource": ""
}
|
q181625
|
SetSession
|
test
|
func (ctx *Context) SetSession(key string, values map[string]string) error {
sid := ctx.genSid(key)
values["Sid"] = sid
timestamp := strconv.FormatInt(time.Now().Unix(), 10)
token := ctx.genSid(key + timestamp)
values["Token"] = token
store, err := provider.Set(sid, values)
if err != nil {
return err
}
cookie := httpCookie
cookie.Value = sid
ctx.Data["session"] = store
respCookie := ctx.ResponseWriter.Header().Get("Set-Cookie")
if strings.HasPrefix(respCookie, cookie.Name) {
ctx.ResponseWriter.Header().Del("Set-Cookie")
}
http.SetCookie(ctx.ResponseWriter, &cookie)
return nil
}
|
go
|
{
"resource": ""
}
|
q181626
|
FreshSession
|
test
|
func (ctx *Context) FreshSession(key string) error {
err := provider.UpExpire(key)
if err != nil {
return err
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181627
|
DeleteSession
|
test
|
func (ctx *Context) DeleteSession() error {
sid := ctx.Data["Sid"].(string)
ctx.Data["session"] = nil
provider.Destroy(sid)
cookie := httpCookie
cookie.MaxAge = -1
http.SetCookie(ctx.ResponseWriter, &cookie)
return nil
}
|
go
|
{
"resource": ""
}
|
q181628
|
Write
|
test
|
func (w contextWriter) Write(p []byte) (int, error) {
w.context.written = true
return w.ResponseWriter.Write(p)
}
|
go
|
{
"resource": ""
}
|
q181629
|
WriteHeader
|
test
|
func (w contextWriter) WriteHeader(code int) {
w.context.written = true
w.ResponseWriter.WriteHeader(code)
}
|
go
|
{
"resource": ""
}
|
q181630
|
New
|
test
|
func New(pemPath string, options ...func(*Client) error) *Client {
c := Client{
pemPath: pemPath,
RequestTimeout: defaultRequestTimeout,
}
c.PrintDebug = false
for _, option := range options {
err := option(&c)
if err != nil {
return nil
}
}
return &c
}
|
go
|
{
"resource": ""
}
|
q181631
|
setAllowLargeResults
|
test
|
func (c *Client) setAllowLargeResults(shouldAllow bool, tempTableName string, flattenResults bool) error {
c.allowLargeResults = shouldAllow
c.tempTableName = tempTableName
c.flattenResults = flattenResults
return nil
}
|
go
|
{
"resource": ""
}
|
q181632
|
connect
|
test
|
func (c *Client) connect() (*bigquery.Service, error) {
if c.token != nil {
if !c.token.Valid() && c.service != nil {
return c.service, nil
}
}
// generate auth token and create service object
//authScope := bigquery.BigqueryScope
pemKeyBytes, err := ioutil.ReadFile(c.pemPath)
if err != nil {
panic(err)
}
t, err := google.JWTConfigFromJSON(
pemKeyBytes,
"https://www.googleapis.com/auth/bigquery")
//t := jwt.NewToken(c.accountEmailAddress, bigquery.BigqueryScope, pemKeyBytes)
client := t.Client(oauth2.NoContext)
service, err := bigquery.New(client)
if err != nil {
return nil, err
}
c.service = service
return service, nil
}
|
go
|
{
"resource": ""
}
|
q181633
|
InsertRow
|
test
|
func (c *Client) InsertRow(projectID, datasetID, tableID string, rowData map[string]interface{}) error {
service, err := c.connect()
if err != nil {
return err
}
insertRequest := buildBigQueryInsertRequest([]map[string]interface{}{rowData})
result, err := service.Tabledata.InsertAll(projectID, datasetID, tableID, insertRequest).Do()
if err != nil {
c.printDebug("Error inserting row: ", err)
return err
}
if len(result.InsertErrors) > 0 {
return errors.New("Error inserting row")
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181634
|
AsyncQuery
|
test
|
func (c *Client) AsyncQuery(pageSize int, dataset, project, queryStr string, dataChan chan Data) {
c.pagedQuery(pageSize, dataset, project, queryStr, dataChan)
}
|
go
|
{
"resource": ""
}
|
q181635
|
Query
|
test
|
func (c *Client) Query(dataset, project, queryStr string) ([][]interface{}, []string, error) {
return c.pagedQuery(defaultPageSize, dataset, project, queryStr, nil)
}
|
go
|
{
"resource": ""
}
|
q181636
|
stdPagedQuery
|
test
|
func (c *Client) stdPagedQuery(service *bigquery.Service, pageSize int, dataset, project, queryStr string, dataChan chan Data) ([][]interface{}, []string, error) {
c.printDebug("std paged query")
datasetRef := &bigquery.DatasetReference{
DatasetId: dataset,
ProjectId: project,
}
query := &bigquery.QueryRequest{
DefaultDataset: datasetRef,
MaxResults: int64(pageSize),
Kind: "json",
Query: queryStr,
}
qr, err := service.Jobs.Query(project, query).Do()
// extract the initial rows that have already been returned with the Query
headers, rows := c.headersAndRows(qr.Schema, qr.Rows)
if err != nil {
c.printDebug("Error loading query: ", err)
if dataChan != nil {
dataChan <- Data{Err: err}
}
return nil, nil, err
}
return c.processPagedQuery(qr.JobReference, qr.PageToken, dataChan, headers, rows)
}
|
go
|
{
"resource": ""
}
|
q181637
|
largeDataPagedQuery
|
test
|
func (c *Client) largeDataPagedQuery(service *bigquery.Service, pageSize int, dataset, project, queryStr string, dataChan chan Data) ([][]interface{}, []string, error) {
c.printDebug("largeDataPagedQuery starting")
ts := time.Now()
// start query
tableRef := bigquery.TableReference{DatasetId: dataset, ProjectId: project, TableId: c.tempTableName}
jobConfigQuery := bigquery.JobConfigurationQuery{}
datasetRef := &bigquery.DatasetReference{
DatasetId: dataset,
ProjectId: project,
}
jobConfigQuery.AllowLargeResults = true
jobConfigQuery.Query = queryStr
jobConfigQuery.DestinationTable = &tableRef
jobConfigQuery.DefaultDataset = datasetRef
if !c.flattenResults {
c.printDebug("setting FlattenResults to false")
// need a pointer to bool
f := false
jobConfigQuery.FlattenResults = &f
}
jobConfigQuery.WriteDisposition = "WRITE_TRUNCATE"
jobConfigQuery.CreateDisposition = "CREATE_IF_NEEDED"
jobConfig := bigquery.JobConfiguration{}
jobConfig.Query = &jobConfigQuery
job := bigquery.Job{}
job.Configuration = &jobConfig
jobInsert := service.Jobs.Insert(project, &job)
runningJob, jerr := jobInsert.Do()
if jerr != nil {
c.printDebug("Error inserting job!", jerr)
if dataChan != nil {
dataChan <- Data{Err: jerr}
}
return nil, nil, jerr
}
var qr *bigquery.GetQueryResultsResponse
var rows [][]interface{}
var headers []string
var err error
// Periodically, job references are not created, but errors are also not thrown.
// In this scenario, retry up to 5 times to get a job reference before giving up.
for i := 1; ; i++ {
r := service.Jobs.GetQueryResults(project, runningJob.JobReference.JobId)
r.TimeoutMs(c.RequestTimeout)
qr, err = r.Do()
headers, rows = c.headersAndRows(qr.Schema, qr.Rows)
if i >= maxRequestRetry || qr.JobReference != nil || err != nil {
if i > 1 {
c.printDebug("Took %v tries to get a job reference", i)
}
break
}
}
if err == nil && qr.JobReference == nil {
err = fmt.Errorf("missing job reference")
}
if err != nil {
c.printDebug("Error loading query: ", err)
if dataChan != nil {
dataChan <- Data{Err: err}
}
return nil, nil, err
}
rows, headers, err = c.processPagedQuery(qr.JobReference, qr.PageToken, dataChan, headers, rows)
c.printDebug("largeDataPagedQuery completed in ", time.Now().Sub(ts).Seconds(), "s")
return rows, headers, err
}
|
go
|
{
"resource": ""
}
|
q181638
|
pagedQuery
|
test
|
func (c *Client) pagedQuery(pageSize int, dataset, project, queryStr string, dataChan chan Data) ([][]interface{}, []string, error) {
// connect to service
service, err := c.connect()
if err != nil {
if dataChan != nil {
dataChan <- Data{Err: err}
}
return nil, nil, err
}
if c.allowLargeResults && len(c.tempTableName) > 0 {
return c.largeDataPagedQuery(service, pageSize, dataset, project, queryStr, dataChan)
}
return c.stdPagedQuery(service, pageSize, dataset, project, queryStr, dataChan)
}
|
go
|
{
"resource": ""
}
|
q181639
|
pageOverJob
|
test
|
func (c *Client) pageOverJob(rowCount int, jobRef *bigquery.JobReference, pageToken string, resultChan chan [][]interface{}, headersChan chan []string) error {
service, err := c.connect()
if err != nil {
return err
}
qrc := service.Jobs.GetQueryResults(jobRef.ProjectId, jobRef.JobId)
if len(pageToken) > 0 {
qrc.PageToken(pageToken)
}
qr, err := qrc.Do()
if err != nil {
c.printDebug("Error loading additional data: ", err)
close(resultChan)
return err
}
if qr.JobComplete {
c.printDebug("qr.JobComplete")
headers, rows := c.headersAndRows(qr.Schema, qr.Rows)
if headersChan != nil {
headersChan <- headers
close(headersChan)
}
// send back the rows we got
c.printDebug("sending rows")
resultChan <- rows
rowCount = rowCount + len(rows)
c.printDebug("Total rows: ", rowCount)
}
if qr.TotalRows > uint64(rowCount) || !qr.JobComplete {
c.printDebug("!qr.JobComplete")
if qr.JobReference == nil {
c.pageOverJob(rowCount, jobRef, pageToken, resultChan, headersChan)
} else {
c.pageOverJob(rowCount, qr.JobReference, qr.PageToken, resultChan, nil)
}
} else {
close(resultChan)
return nil
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181640
|
Count
|
test
|
func (c *Client) Count(dataset, project, datasetTable string) int64 {
qstr := fmt.Sprintf("select count(*) from [%s]", datasetTable)
res, err := c.SyncQuery(dataset, project, qstr, 1)
if err == nil {
if len(res) > 0 {
val, _ := strconv.ParseInt(res[0][0].(string), 10, 64)
return val
}
}
return 0
}
|
go
|
{
"resource": ""
}
|
q181641
|
work
|
test
|
func work(args ...interface{}) interface{} {
url := args[0].(string)
depth := args[1].(int)
fetcher := args[2].(Fetcher)
if depth <= 0 {
return crawlResult{}
}
body, urls, err := fetcher.Fetch(url)
return crawlResult{body, urls, err}
}
|
go
|
{
"resource": ""
}
|
q181642
|
subworker
|
test
|
func (pool *Pool) subworker(job *Job) {
defer func() {
if err := recover(); err != nil {
log.Println("panic while running job:", err)
job.Result = nil
job.Err = fmt.Errorf(err.(string))
}
}()
job.Result = job.F(job.Args...)
}
|
go
|
{
"resource": ""
}
|
q181643
|
worker
|
test
|
func (pool *Pool) worker(worker_id uint) {
job_pipe := make(chan *Job)
WORKER_LOOP:
for {
pool.job_wanted_pipe <- job_pipe
job := <-job_pipe
if job == nil {
time.Sleep(pool.interval * time.Millisecond)
} else {
job.Worker_id = worker_id
pool.subworker(job)
pool.done_pipe <- job
}
select {
case <-pool.worker_kill_pipe:
break WORKER_LOOP
default:
}
}
pool.worker_wg.Done()
}
|
go
|
{
"resource": ""
}
|
q181644
|
supervisor
|
test
|
func (pool *Pool) supervisor() {
SUPERVISOR_LOOP:
for {
select {
// new job
case job := <-pool.add_pipe:
pool.jobs_ready_to_run.PushBack(job)
pool.num_jobs_submitted++
job.added <- true
// send jobs to the workers
case job_pipe := <-pool.job_wanted_pipe:
element := pool.jobs_ready_to_run.Front()
var job *Job = nil
if element != nil {
job = element.Value.(*Job)
pool.num_jobs_running++
pool.jobs_ready_to_run.Remove(element)
}
job_pipe <- job
// job completed
case job := <-pool.done_pipe:
pool.num_jobs_running--
pool.jobs_completed.PushBack(job)
pool.num_jobs_completed++
// wait for job
case result_pipe := <-pool.result_wanted_pipe:
close_pipe := false
job := (*Job)(nil)
element := pool.jobs_completed.Front()
if element != nil {
job = element.Value.(*Job)
pool.jobs_completed.Remove(element)
} else {
if pool.num_jobs_running == 0 && pool.num_jobs_completed == pool.num_jobs_submitted {
close_pipe = true
}
}
if close_pipe {
close(result_pipe)
} else {
result_pipe <- job
}
// is the pool working or just lazing on a Sunday afternoon?
case working_pipe := <-pool.working_wanted_pipe:
working := true
if pool.jobs_ready_to_run.Len() == 0 && pool.num_jobs_running == 0 {
working = false
}
working_pipe <- working
// stats
case stats_pipe := <-pool.stats_wanted_pipe:
pool_stats := stats{pool.num_jobs_submitted, pool.num_jobs_running, pool.num_jobs_completed}
stats_pipe <- pool_stats
// stopping
case <-pool.supervisor_kill_pipe:
break SUPERVISOR_LOOP
}
}
pool.supervisor_wg.Done()
}
|
go
|
{
"resource": ""
}
|
q181645
|
Run
|
test
|
func (pool *Pool) Run() {
if pool.workers_started {
panic("trying to start a pool that's already running")
}
for i := uint(0); i < uint(pool.num_workers); i++ {
pool.worker_wg.Add(1)
go pool.worker(i)
}
pool.workers_started = true
// handle the supervisor
if !pool.supervisor_started {
pool.startSupervisor()
}
}
|
go
|
{
"resource": ""
}
|
q181646
|
Add
|
test
|
func (pool *Pool) Add(f func(...interface{}) interface{}, args ...interface{}) {
job := &Job{f, args, nil, nil, make(chan bool), 0, pool.getNextJobId()}
pool.add_pipe <- job
<-job.added
}
|
go
|
{
"resource": ""
}
|
q181647
|
Wait
|
test
|
func (pool *Pool) Wait() {
working_pipe := make(chan bool)
for {
pool.working_wanted_pipe <- working_pipe
if !<-working_pipe {
break
}
time.Sleep(pool.interval * time.Millisecond)
}
}
|
go
|
{
"resource": ""
}
|
q181648
|
Results
|
test
|
func (pool *Pool) Results() (res []*Job) {
res = make([]*Job, pool.jobs_completed.Len())
i := 0
for e := pool.jobs_completed.Front(); e != nil; e = e.Next() {
res[i] = e.Value.(*Job)
i++
}
pool.jobs_completed = list.New()
return
}
|
go
|
{
"resource": ""
}
|
q181649
|
WaitForJob
|
test
|
func (pool *Pool) WaitForJob() *Job {
result_pipe := make(chan *Job)
var job *Job
var ok bool
for {
pool.result_wanted_pipe <- result_pipe
job, ok = <-result_pipe
if !ok {
// no more results available
return nil
}
if job == (*Job)(nil) {
// no result available right now but there are jobs running
time.Sleep(pool.interval * time.Millisecond)
} else {
break
}
}
return job
}
|
go
|
{
"resource": ""
}
|
q181650
|
Status
|
test
|
func (pool *Pool) Status() stats {
stats_pipe := make(chan stats)
if pool.supervisor_started {
pool.stats_wanted_pipe <- stats_pipe
return <-stats_pipe
}
// the supervisor wasn't started so we return a zeroed structure
return stats{}
}
|
go
|
{
"resource": ""
}
|
q181651
|
WrapHTTPHandlerFunc
|
test
|
func WrapHTTPHandlerFunc(f http.HandlerFunc) HandlerFunc {
newF := func(ctx *Context) error {
f(ctx.Response, ctx.Request)
return nil
}
return newF
}
|
go
|
{
"resource": ""
}
|
q181652
|
WebSocketHandlerFunc
|
test
|
func WebSocketHandlerFunc(f func(ws *websocket.Conn)) HandlerFunc {
h := websocket.Handler(f)
return WrapHTTPHandlerFunc(h.ServeHTTP)
}
|
go
|
{
"resource": ""
}
|
q181653
|
StaticFile
|
test
|
func StaticFile(filename string, contentType string) staticFile {
if contentType == "" {
contentType = mime.TypeByExtension(path.Ext(filename))
}
header := make(http.Header)
header.Set("Content-Type", contentType)
return staticFile{filename, header}
}
|
go
|
{
"resource": ""
}
|
q181654
|
PreloadFile
|
test
|
func PreloadFile(filename string, contentType string) (preloadFile, error) {
body, err := ioutil.ReadFile(filename)
if err != nil {
return preloadFile{}, err
}
if contentType == "" {
contentType = mime.TypeByExtension(path.Ext(filename))
}
header := make(http.Header)
header.Set("Content-Type", contentType)
return preloadFile{body, header}, nil
}
|
go
|
{
"resource": ""
}
|
q181655
|
InitHtmlTemplates
|
test
|
func InitHtmlTemplates(pattern string) (err error) {
htmlTemp.Template, err = html.ParseGlob(pattern)
return
}
|
go
|
{
"resource": ""
}
|
q181656
|
InitTextTemplates
|
test
|
func InitTextTemplates(pattern string) (err error) {
textTemp.Template, err = text.ParseGlob(pattern)
return nil
}
|
go
|
{
"resource": ""
}
|
q181657
|
Html
|
test
|
func Html(name, contentType, charSet string) template {
if htmlTemp.Template == nil {
panic("Function `InitHtmlTemplates` should be called first.")
}
if contentType == "" {
contentType = ContentTypeHTML
}
if charSet == "" {
charSet = CharSetUTF8
}
header := make(http.Header)
header.Set("Content-Type",
fmt.Sprintf("%s; charset=%s", contentType, charSet))
return template{&htmlTemp, name, header}
}
|
go
|
{
"resource": ""
}
|
q181658
|
Text
|
test
|
func Text(name, contentType, charSet string) template {
if textTemp.Template == nil {
panic("Function `InitTextTemplates` should be called first.")
}
if contentType == "" {
contentType = ContentTypePlain
}
if charSet == "" {
charSet = CharSetUTF8
}
header := make(http.Header)
header.Set("Content-Type",
fmt.Sprintf("%s; charset=%s", contentType, charSet))
return template{&textTemp, name, header}
}
|
go
|
{
"resource": ""
}
|
q181659
|
InitWatcher
|
test
|
func InitWatcher(pattern string, f func(string) error, ef func(error)) (err error) {
if err = f(pattern); err != nil {
return
}
if watcher.Watcher == nil {
watcher.Watcher, err = fsnotify.NewWatcher()
if err != nil {
return
}
watcher.closer = make(chan bool)
}
go func() {
atomic.AddUint32(&watcher.count, 1)
for {
select {
case <-watcher.Events:
if err := f(pattern); err != nil {
ef(err)
}
case err := <-watcher.Errors:
if ef != nil {
ef(err)
}
case <-watcher.closer:
break
}
}
}()
var matches []string
matches, err = filepath.Glob(pattern)
if err != nil {
return
}
for _, v := range matches {
if err = watcher.Add(v); err != nil {
return
}
}
return
}
|
go
|
{
"resource": ""
}
|
q181660
|
CloseWatcher
|
test
|
func CloseWatcher() error {
for i := uint32(0); i < watcher.count; i++ {
watcher.closer <- true
}
return watcher.Close()
}
|
go
|
{
"resource": ""
}
|
q181661
|
Find
|
test
|
func (rs *Routers) Find(path string) (url.Values, HandlerFunc, view.View) {
defer rs.RUnlock()
rs.RLock()
if s, ok := rs.s[path]; ok {
return nil, s.h, s.v
}
for e := rs.l.Front(); e != nil; e = e.Next() {
s := e.Value.(struct {
r router.Router
v view.View
h HandlerFunc
})
if params, ok := s.r.Match(path); ok {
return params, s.h, s.v
}
}
return nil, nil, nil
}
|
go
|
{
"resource": ""
}
|
q181662
|
Add
|
test
|
func (rs *Routers) Add(r router.Router, h HandlerFunc, v view.View) {
defer rs.Unlock()
rs.Lock()
s := struct {
r router.Router
v view.View
h HandlerFunc
}{r, v, h}
// simple will full-match the path
if sr, ok := r.(*router.Base); ok {
rs.s[sr.Path] = s
return
}
rs.l.PushFront(s)
}
|
go
|
{
"resource": ""
}
|
q181663
|
NewRouters
|
test
|
func NewRouters() *Routers {
return &Routers{
s: make(map[string]struct {
r router.Router
v view.View
h HandlerFunc
}),
l: list.New(),
}
}
|
go
|
{
"resource": ""
}
|
q181664
|
NewServerMux
|
test
|
func NewServerMux() (mux *ServerMux) {
nf := struct {
View view.View
Handler HandlerFunc
}{view.Simple(view.ContentTypePlain, view.CharSetUTF8), defaultNotFound}
return &ServerMux{NewRouters(), nil, nil, nil, nf}
}
|
go
|
{
"resource": ""
}
|
q181665
|
err
|
test
|
func (mux *ServerMux) err(err error) {
if mux.ErrorHandle != nil {
mux.ErrorHandle(err)
}
}
|
go
|
{
"resource": ""
}
|
q181666
|
HandleFunc
|
test
|
func (mux *ServerMux) HandleFunc(r router.Router, h HandlerFunc, v view.View) {
mux.routers.Add(r, h, v)
}
|
go
|
{
"resource": ""
}
|
q181667
|
handleError
|
test
|
func (mux *ServerMux) handleError(ctx *Context, err error) bool {
if err == nil {
return false
}
if e, ok := err.(Error); ok {
ctx.Response.Status = e.Status
ctx.Response.Data = e
return true
}
if ctx.Response.Status == http.StatusOK {
ctx.Response.Status = http.StatusInternalServerError
}
ctx.Response.Data = err.Error()
mux.err(err)
return true
}
|
go
|
{
"resource": ""
}
|
q181668
|
Redirect
|
test
|
func (ctx *Context) Redirect(code int, url string) {
ctx.Response.Status = code
ctx.Response.Data = url
}
|
go
|
{
"resource": ""
}
|
q181669
|
InitPProf
|
test
|
func (mux *ServerMux) InitPProf(prefix string) {
if prefix == "" {
prefix = "/debug/pprof"
}
mux.HandleFunc(router.Wildcard(fmt.Sprintf("%s/*", prefix)),
WrapHTTPHandlerFunc(pprofIndex(prefix)), nil)
mux.HandleFunc(router.Simple(fmt.Sprintf("%s/cmdline", prefix)),
WrapHTTPHandlerFunc(http.HandlerFunc(pprof.Cmdline)), nil)
mux.HandleFunc(router.Simple(fmt.Sprintf("%s/profile", prefix)),
WrapHTTPHandlerFunc(http.HandlerFunc(pprof.Profile)), nil)
mux.HandleFunc(router.Simple(fmt.Sprintf("%s/symbol", prefix)),
WrapHTTPHandlerFunc(http.HandlerFunc(pprof.Symbol)), nil)
}
|
go
|
{
"resource": ""
}
|
q181670
|
StartSession
|
test
|
func (ctx *Context) StartSession(f session.FactoryFunc) (err error) {
ctx.Session, err = f(ctx.Response, ctx.Request)
return
}
|
go
|
{
"resource": ""
}
|
q181671
|
combinations
|
test
|
func combinations(list []int, select_num, buf int) (c chan []int) {
c = make(chan []int, buf)
go func() {
defer close(c)
switch {
case select_num == 0:
c <- []int{}
case select_num == len(list):
c <- list
case len(list) < select_num:
return
default:
for i := 0; i < len(list); i++ {
for sub_comb := range combinations(list[i+1:], select_num-1, buf) {
c <- append([]int{list[i]}, sub_comb...)
}
}
}
}()
return
}
|
go
|
{
"resource": ""
}
|
q181672
|
repeated_combinations
|
test
|
func repeated_combinations(list []int, select_num, buf int) (c chan []int) {
c = make(chan []int, buf)
go func() {
defer close(c)
if select_num == 1 {
for v := range list {
c <- []int{v}
}
return
}
for i := 0; i < len(list); i++ {
for sub_comb := range repeated_combinations(list[i:], select_num-1, buf) {
c <- append([]int{list[i]}, sub_comb...)
}
}
}()
return
}
|
go
|
{
"resource": ""
}
|
q181673
|
permutations
|
test
|
func permutations(list []int, select_num, buf int) (c chan []int) {
c = make(chan []int, buf)
go func() {
defer close(c)
switch select_num {
case 1:
for _, v := range list {
c <- []int{v}
}
return
case 0:
return
case len(list):
for i := 0; i < len(list); i++ {
top, sub_list := pop(list, i)
for perm := range permutations(sub_list, select_num-1, buf) {
c <- append([]int{top}, perm...)
}
}
default:
for comb := range combinations(list, select_num, buf) {
for perm := range permutations(comb, select_num, buf) {
c <- perm
}
}
}
}()
return
}
|
go
|
{
"resource": ""
}
|
q181674
|
repeated_permutations
|
test
|
func repeated_permutations(list []int, select_num, buf int) (c chan []int) {
c = make(chan []int, buf)
go func() {
defer close(c)
switch select_num {
case 1:
for _, v := range list {
c <- []int{v}
}
default:
for i := 0; i < len(list); i++ {
for perm := range repeated_permutations(list, select_num-1, buf) {
c <- append([]int{list[i]}, perm...)
}
}
}
}()
return
}
|
go
|
{
"resource": ""
}
|
q181675
|
gformat
|
test
|
func gformat(format string, args map[string]interface{}) (string, []interface{}) {
// holder for new format string - capacity as length of provided string
// should be enough not to resize during appending, since expected length
// of new format is smaller then provided one (names are removed)
var new_format = make([]rune, 0, len(format))
// flag that indicates if current place in format string in inside { }
var in_format = false
// flag that indicates if current place is format string in inside { } and after :
var in_args = false
var previousChar rune
// temp slice for holding name in current format
var current_name_runes = make([]rune, 0, 10)
// temp slice for holding args in current format
var current_args_runes = make([]rune, 0, 10)
var new_format_params []interface{}
for i, ch := range format {
if i > 0 {
previousChar = rune(format[i-1])
}
switch ch {
case '{':
if in_format && previousChar == '{' {
in_format = false
new_format = append(new_format, ch)
break
}
in_format = true
case '}':
if !in_format {
if previousChar == '}' {
new_format = append(new_format, ch)
break
}
// what to do if not in_format and only single } appears?
break
}
if in_format {
if len(current_args_runes) > 0 {
// append formatting arguments to new_format directly
new_format = append(new_format, current_args_runes...)
} else {
// if no arguments are supplied, use default ones
new_format = append(new_format, defaultFormat...)
}
// reset format args for new iteration
current_args_runes = current_args_runes[0:0]
}
var name string
if len(current_name_runes) == 0 {
name = "EMPTY_PLACEHOLDER"
} else {
name = string(current_name_runes)
}
// reset name runes for next iteration
current_name_runes = current_name_runes[0:0]
// get value from provided args and append it to new_format_args
val, ok := args[name]
if !ok {
val = fmt.Sprintf("%%MISSING=%s", name)
}
new_format_params = append(new_format_params, val)
// reset flags
in_format = false
in_args = false
case ':':
if in_format {
in_args = true
}
default:
if in_format {
if in_args {
current_args_runes = append(current_args_runes, ch)
} else {
current_name_runes = append(current_name_runes, ch)
}
} else {
new_format = append(new_format, ch)
}
}
}
return string(new_format), new_format_params
}
|
go
|
{
"resource": ""
}
|
q181676
|
Errorm
|
test
|
func Errorm(format string, args map[string]interface{}) error {
f, a := gformat(format, args)
return fmt.Errorf(f, a...)
}
|
go
|
{
"resource": ""
}
|
q181677
|
Fprintm
|
test
|
func Fprintm(w io.Writer, format string, args map[string]interface{}) (n int, err error) {
f, a := gformat(format, args)
return fmt.Fprintf(w, f, a...)
}
|
go
|
{
"resource": ""
}
|
q181678
|
Printm
|
test
|
func Printm(format string, args map[string]interface{}) (n int, err error) {
f, a := gformat(format, args)
return fmt.Printf(f, a...)
}
|
go
|
{
"resource": ""
}
|
q181679
|
Sprintm
|
test
|
func Sprintm(format string, args map[string]interface{}) string {
f, a := gformat(format, args)
return fmt.Sprintf(f, a...)
}
|
go
|
{
"resource": ""
}
|
q181680
|
Validate
|
test
|
func (p *PasswordStrengthRequirements) Validate(password string) (bool, string) {
reqs := MakeRequirements(password)
if p.MaximumTotalLength > 0 && reqs.MaximumTotalLength > p.MaximumTotalLength {
return false, "password is too long"
}
if reqs.MinimumTotalLength < p.MinimumTotalLength {
return false, "password is too short"
}
if reqs.Digits < p.Digits {
return false, "password has too few digits"
}
if reqs.Punctuation < p.Punctuation {
return false, "password has too few punctuation characters"
}
if reqs.Uppercase < p.Uppercase {
return false, "password has too few uppercase characters"
}
return true, ""
}
|
go
|
{
"resource": ""
}
|
q181681
|
MakeRequirements
|
test
|
func MakeRequirements(password string) PasswordStrengthRequirements {
pwd := []byte(password)
reqs := PasswordStrengthRequirements{}
reqs.MaximumTotalLength = len(password)
reqs.MinimumTotalLength = len(password)
for i := range pwd {
switch {
case unicode.IsDigit(rune(pwd[i])):
reqs.Digits++
case unicode.IsUpper(rune(pwd[i])):
reqs.Uppercase++
case unicode.IsPunct(rune(pwd[i])):
reqs.Punctuation++
}
}
return reqs
}
|
go
|
{
"resource": ""
}
|
q181682
|
sanityCheck
|
test
|
func (p *PasswordStrengthRequirements) sanityCheck() (bool, string) {
if p.MaximumTotalLength == 0 {
return true, ""
}
if p.MaximumTotalLength < p.MinimumTotalLength {
return false, "maximum total length is less than minimum total length"
}
if p.MaximumTotalLength < p.Digits {
return false, "maximum required digits is more than maximum total length"
}
if p.MaximumTotalLength < p.Punctuation {
return false, "maximum required punctuation is more than maximum total length"
}
if p.MaximumTotalLength < p.Uppercase {
return false, "maximum required uppercase characters is more than maximum total length"
}
if p.MaximumTotalLength < p.Digits+p.Uppercase+p.Punctuation {
return false, "maximum required digits + uppercase + punctuation is more than maximum total length"
}
return true, ""
}
|
go
|
{
"resource": ""
}
|
q181683
|
password
|
test
|
func (g Garbler) password(req PasswordStrengthRequirements) (string, error) {
//Step 1: Figure out settings
letters := 0
mustGarble := 0
switch {
case req.MaximumTotalLength > 0 && req.MaximumTotalLength > 6:
letters = req.MaximumTotalLength - req.Digits - req.Punctuation
case req.MaximumTotalLength > 0 && req.MaximumTotalLength <= 6:
letters = req.MaximumTotalLength - req.Punctuation
mustGarble = req.Digits
case req.MinimumTotalLength > req.Digits+req.Punctuation+6:
letters = req.MinimumTotalLength - req.Digits - req.Punctuation
default:
letters = req.MinimumTotalLength
}
if req.Uppercase > letters {
letters = req.Uppercase
}
password := g.garbledSequence(letters, mustGarble)
password = g.uppercase(password, req.Uppercase)
password = g.addNums(password, req.Digits-mustGarble)
password = g.punctuate(password, req.Punctuation)
return password, nil
}
|
go
|
{
"resource": ""
}
|
q181684
|
NewPassword
|
test
|
func NewPassword(reqs *PasswordStrengthRequirements) (string, error) {
if reqs == nil {
reqs = &Medium
}
if ok, problems := reqs.sanityCheck(); !ok {
return "", errors.New("requirements failed validation: " + problems)
}
e := Garbler{}
return e.password(*reqs)
}
|
go
|
{
"resource": ""
}
|
q181685
|
NewPasswords
|
test
|
func NewPasswords(reqs *PasswordStrengthRequirements, n int) ([]string, error) {
var err error
if reqs == nil {
reqs = &Medium
}
if ok, problems := reqs.sanityCheck(); !ok {
return nil, errors.New("requirements failed validation: " + problems)
}
e := Garbler{}
passes := make([]string, n, n)
for i := 0; i < n; i++ {
passes[i], err = e.password(*reqs)
if err != nil {
return nil, err
}
}
return passes, nil
}
|
go
|
{
"resource": ""
}
|
q181686
|
addNums
|
test
|
func (g Garbler) addNums(p string, numDigits int) string {
if numDigits <= 0 {
return p
}
ret := p
remaining := numDigits
for remaining > 10 {
ret += fmt.Sprintf("%d", pow(10, 9)+randInt(pow(10, 10)-pow(10, 9)))
remaining -= 10
}
ret += fmt.Sprintf("%d", pow(10, remaining-1)+randInt(pow(10, remaining)-pow(10, remaining-1)))
return ret
}
|
go
|
{
"resource": ""
}
|
q181687
|
punctuate
|
test
|
func (g Garbler) punctuate(p string, numPunc int) string {
if numPunc <= 0 {
return p
}
ret := p
for i := 0; i < numPunc; i++ {
if i%2 == 0 {
ret += string(Punctuation[randInt(len(Punctuation))])
} else {
ret = string(Punctuation[randInt(len(Punctuation))]) + ret
}
}
return ret
}
|
go
|
{
"resource": ""
}
|
q181688
|
deprecated_init
|
test
|
func deprecated_init() {
// if piping from stdin we can just exit
// and use the default Stdin value
stat, _ := os.Stdin.Stat()
if (stat.Mode() & os.ModeCharDevice) == 0 {
return
}
// check for params after the double dash
// in the command string
for i, argv := range os.Args {
if argv == "--" {
arg := os.Args[i+1]
buf := bytes.NewBufferString(arg)
Stdin = NewParamSet(buf)
return
}
}
// else use the first variable in the list
if len(os.Args) > 1 {
buf := bytes.NewBufferString(os.Args[1])
Stdin = NewParamSet(buf)
}
}
|
go
|
{
"resource": ""
}
|
q181689
|
Param
|
test
|
func (p ParamSet) Param(name string, value interface{}) {
p.params[name] = value
}
|
go
|
{
"resource": ""
}
|
q181690
|
Parse
|
test
|
func (p ParamSet) Parse() error {
raw := map[string]json.RawMessage{}
err := json.NewDecoder(p.reader).Decode(&raw)
if err != nil {
return err
}
for key, val := range p.params {
data, ok := raw[key]
if !ok {
continue
}
err := json.Unmarshal(data, val)
if err != nil {
return fmt.Errorf("Unable to unarmshal %s. %s", key, err)
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q181691
|
Unmarshal
|
test
|
func (p ParamSet) Unmarshal(v interface{}) error {
return json.NewDecoder(p.reader).Decode(v)
}
|
go
|
{
"resource": ""
}
|
q181692
|
GetDefaultHTTPClient
|
test
|
func GetDefaultHTTPClient(timeout time.Duration) IHTTPClient {
client := http.Client{
Timeout: timeout,
}
return IHTTPClient(&client)
}
|
go
|
{
"resource": ""
}
|
q181693
|
DeviceInfo
|
test
|
func (p Pushy) DeviceInfo(deviceID string) (*DeviceInfo, *Error, error) {
url := fmt.Sprintf("%s/devices/%s?api_key=%s", p.APIEndpoint, deviceID, p.APIToken)
var errResponse *Error
var info *DeviceInfo
err := get(p.httpClient, url, &info, &errResponse)
return info, errResponse, err
}
|
go
|
{
"resource": ""
}
|
q181694
|
DevicePresence
|
test
|
func (p *Pushy) DevicePresence(deviceID ...string) (*DevicePresenceResponse, *Error, error) {
url := fmt.Sprintf("%s/devices/presence?api_key=%s", p.APIEndpoint, p.APIToken)
var devicePresenceResponse *DevicePresenceResponse
var pushyErr *Error
err := post(p.httpClient, url, DevicePresenceRequest{Tokens: deviceID}, &devicePresenceResponse, &pushyErr)
return devicePresenceResponse, pushyErr, err
}
|
go
|
{
"resource": ""
}
|
q181695
|
NotificationStatus
|
test
|
func (p *Pushy) NotificationStatus(pushID string) (*NotificationStatus, *Error, error) {
url := fmt.Sprintf("%s/pushes/%s?api_key=%s", p.APIEndpoint, pushID, p.APIToken)
var errResponse *Error
var status *NotificationStatus
err := get(p.httpClient, url, &status, &errResponse)
return status, errResponse, err
}
|
go
|
{
"resource": ""
}
|
q181696
|
DeleteNotification
|
test
|
func (p *Pushy) DeleteNotification(pushID string) (*SimpleSuccess, *Error, error) {
url := fmt.Sprintf("%s/pushes/%s?api_key=%s", p.APIEndpoint, pushID, p.APIToken)
var success *SimpleSuccess
var pushyErr *Error
err := del(p.httpClient, url, &success, &pushyErr)
return success, pushyErr, err
}
|
go
|
{
"resource": ""
}
|
q181697
|
NotifyDevice
|
test
|
func (p *Pushy) NotifyDevice(request SendNotificationRequest) (*NotificationResponse, *Error, error) {
url := fmt.Sprintf("%s/push?api_key=%s", p.APIEndpoint, p.APIToken)
var success *NotificationResponse
var pushyErr *Error
err := post(p.httpClient, url, request, &success, &pushyErr)
return success, pushyErr, err
}
|
go
|
{
"resource": ""
}
|
q181698
|
Assert
|
test
|
func Assert(t Tester, b bool, message ...interface{}) {
if !b {
pc, file, line, _ := runtime.Caller(1)
caller_func_info := runtime.FuncForPC(pc)
error_string := fmt.Sprintf("\n\rASSERT:\tfunc (%s) 0x%x\n\r\tFile %s:%d",
caller_func_info.Name(),
pc,
file,
line)
if len(message) > 0 {
error_string += fmt.Sprintf("\n\r\tInfo: %+v", message)
}
t.Errorf(error_string)
t.FailNow()
}
}
|
go
|
{
"resource": ""
}
|
q181699
|
CreateFile
|
test
|
func CreateFile(filename string, size int64) error {
buf := make([]byte, size)
// Create the file store some data
fp, err := os.Create(filename)
if err != nil {
return err
}
// Write the buffer
_, err = fp.Write(buf)
// Cleanup
fp.Close()
return err
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.