text stringlengths 11 6.3k | embedding listlengths 768 768 |
|---|---|
func (o *TaskRequest) HasTaskOptions() bool {
if o != nil && o.TaskOptions != nil {
return true
}
return false
} | [
-0.12625934183597565,
0.7310033440589905,
0.35824689269065857,
0.3447384536266327,
-0.066937156021595,
-0.8623360991477966,
0.5981395244598389,
-0.3005668818950653,
-0.5547798275947571,
0.47486793994903564,
-1.178614854812622,
-1.7796986103057861,
0.5927010178565979,
0.9712934494018555,
... |
func (o *TaskRequest) SetTaskOptions(v TaskOptions) {
o.TaskOptions = &v
} | [
-0.12367947399616241,
0.4365258812904358,
0.05472784489393234,
0.8249571919441223,
-0.4664645791053772,
-0.20698103308677673,
0.5035751461982727,
-1.9774844646453857,
-0.2013644129037857,
0.9329469799995422,
-0.5926282405853271,
-0.14073674380779266,
0.4202527701854706,
0.27463647723197937... |
func Exec(x Execer, query string, args ...interface{}) (res sql.Result, err error) {
res, err = x.Exec(query, args...)
err = interpretError(err)
return
} | [
0.5245935320854187,
0.7557574510574341,
0.49354323744773865,
0.19029268622398376,
-0.8760830163955688,
-0.3625926375389099,
-1.6005525588989258,
0.1372392624616623,
-0.6284629702568054,
0.26596584916114807,
0.11941923946142197,
-0.1646142452955246,
0.37028414011001587,
-1.0003446340560913,... |
func Query(q Queryer, query string, args ...interface{}) (rows *sql.Rows, err error) {
rows, err = q.Query(query, args...)
err = interpretError(err)
return
} | [
0.5261557698249817,
0.3491290509700775,
0.3520859479904175,
0.32195958495140076,
-0.899332582950592,
-0.5676853656768799,
-1.0325859785079956,
0.8172716498374939,
0.06494525820016861,
-0.34827107191085815,
0.7058430910110474,
-0.3885992467403412,
0.03900846838951111,
0.7698847651481628,
... |
func Prepare(p Preparer, query string) (st *sql.Stmt, err error) {
st, err = p.Prepare(query)
err = interpretError(err)
return
} | [
-0.09526276588439941,
0.037037186324596405,
0.178043931722641,
0.1194729208946228,
-1.7929834127426147,
-0.4828997254371643,
-1.5199843645095825,
-0.10901936143636703,
0.233124241232872,
-0.06273485720157623,
0.5280079245567322,
-0.3074811100959778,
-0.36642149090766907,
-0.344623148441314... |
func Each(rows *sql.Rows, fn func() (dest []interface{})) (num int, err error) {
defer rows.Close()
for rows.Next() {
err = rows.Scan(fn()...)
if err != nil {
err = interpretScanError(err)
return
}
num++
}
return
} | [
-1.2159537076950073,
0.3776475489139557,
0.6410778164863586,
0.3304220139980316,
-0.46159628033638,
-0.6189222931861877,
0.13962145149707794,
0.07549344003200531,
-0.2562936246395111,
-0.36769455671310425,
0.3366435766220093,
-0.19019867479801178,
0.6464778780937195,
0.32203689217567444,
... |
func QueryEach(q Queryer, fn func() (dest []interface{}), query string, args ...interface{}) (num int, err error) {
var rows *sql.Rows
rows, err = Query(q, query, args...)
if err != nil {
return
}
return Each(rows, fn)
} | [
-0.21180017292499542,
0.23877038061618805,
0.5236849784851074,
0.26174482703208923,
-0.1491219401359558,
-0.39100968837738037,
-0.48857975006103516,
0.07692952454090118,
-0.7817386388778687,
-0.4187796413898468,
0.4251938760280609,
-0.3074743151664734,
0.5684370994567871,
0.589778065681457... |
func Transaction(db *sql.DB, fns ...func(DB) error) error {
tx, err := db.Begin()
if err != nil {
return err
}
for _, fn := range fns {
err := fn(tx)
if err != nil {
tx.Rollback()
return err
}
}
err = tx.Commit()
err = interpretScanError(err)
return err
} | [
-0.59968101978302,
1.001735806465149,
0.7450204491615295,
0.27986040711402893,
0.7831797003746033,
-0.16075479984283447,
0.25884538888931274,
0.20078936219215393,
0.4176225960254669,
0.4612245261669159,
-0.48921337723731995,
-1.0728613138198853,
-0.44495683908462524,
-0.4551284909248352,
... |
func (s *Stats) Update(c *gin.Context, last time.Time) {
StatsWith(c, s.update(last))
} | [
0.5388122200965881,
-0.1737399697303772,
0.2639526128768921,
-0.4050428867340088,
0.41634401679039,
0.09003395587205887,
-0.5061129927635193,
-1.083947777748108,
0.27467724680900574,
-0.1000036969780922,
0.008653644472360611,
0.2527700364589691,
0.38909026980400085,
0.4279547929763794,
-... |
func LoadPackage(packageName string, world w.World) error {
var packageErr error
// Load file
file, err := os.Open(fmt.Sprintf("levels/%s/levels.txt", packageName))
utils.LogError(err)
defer file.Close()
lines := []string{}
scanner := bufio.NewScanner(file)
for scanner.Scan() {
line := scanner.Text()
line... | [
-0.19866646826267242,
-0.35623663663864136,
1.037470817565918,
-0.39632314443588257,
-0.058336805552244186,
0.4569876790046692,
-0.08080394566059113,
0.10996265709400177,
-0.709632158279419,
0.6953238844871521,
0.637803852558136,
-0.7386547923088074,
-0.4724559485912323,
1.0754390954971313... |
func PreloadLevel(world w.World, lines []string) (*loader.EntityComponentList, error) {
gridWidth := 0
gridHeight := len(lines)
playerCount, boxCount, goalCount := 0, 0, 0
for _, line := range lines {
gridWidth = math.Max(gridWidth, len(line))
playerCount += strings.Count(line, string(charPlayer)) + strings.Cou... | [
-0.19095966219902039,
-0.32877886295318604,
0.9139902591705322,
-0.5707191228866577,
-0.10959671437740326,
0.7252858281135559,
0.21558721363544464,
-0.46540242433547974,
-0.029293663799762726,
0.1254279911518097,
0.1328166276216507,
-0.5406566262245178,
0.15968871116638184,
0.9394086599349... |
func GetProcessByPID(PID int) (Process, error) {
// Try to open the folder to see if it exists and if we have access to it.
f, err := os.Open(fmt.Sprintf("/proc/%d", PID))
defer f.Close()
if err != nil {
return Process{}, errors.New(fmt.Sprintf("Error opening /proc/%d", PID))
}
return Process{PID: uint64(PID)}... | [
0.7838471531867981,
-0.20757420361042023,
0.4938938617706299,
-0.14125265181064606,
0.21756437420845032,
-0.41610002517700195,
0.3822365701198578,
-0.9176816344261169,
0.5083210468292236,
-0.5004298090934753,
0.36142417788505554,
-0.05390262231230736,
-0.12661416828632355,
0.06001333519816... |
func GetProcessByFileName(fileName string) (Process, error) {
// Open the /proc *nix directory.
procDir, err := os.Open("/proc")
defer procDir.Close()
if err != nil {
fmt.Println(err)
return Process{}, errors.New("Error on opening /proc")
}
// Read in the directory names. Processes are listed
// as folders ... | [
0.3561226725578308,
-0.49176302552223206,
0.8482781648635864,
0.3752036988735199,
0.21876096725463867,
-0.4234713315963745,
1.027254343032837,
-0.7313469648361206,
-0.12190458923578262,
-0.16225281357765198,
0.8391280174255371,
0.3399837911128998,
0.0225532166659832,
0.04504164308309555,
... |
func (p *Process) read(addr uintptr, ptr interface{}) error {
// Reflection magic!
v := reflect.ValueOf(ptr)
dataAddr := getDataAddr(v)
dataSize := getDataSize(v)
// Open the file mapped process memory.
mem, err := os.Open(fmt.Sprintf("/proc/%d/mem", p.PID))
defer mem.Close()
if err != nil {
return errors.Ne... | [
0.3090754449367523,
-0.4806259870529175,
0.8228142261505127,
-0.609488308429718,
-0.8730326890945435,
0.3259163200855255,
-0.0891432911157608,
-0.44211697578430176,
0.32706189155578613,
-0.04364868253469467,
0.6956388354301453,
1.2667087316513062,
0.10450884699821472,
0.20757140219211578,
... |
func (p *Process) write(addr uintptr, ptr interface{}) error {
// Reflection magic!
v := reflect.ValueOf(ptr)
dataAddr := getDataAddr(v)
dataSize := getDataSize(v)
// Open the file mapped process memory.
mem, err := os.OpenFile(fmt.Sprintf("/proc/%d/mem", p.PID), os.O_WRONLY, 0666)
defer mem.Close()
if err != ... | [
0.04625516012310982,
-0.3094293177127838,
0.6341555714607239,
-0.6020358800888062,
-0.05294262617826462,
0.014241136610507965,
0.10393953323364258,
-0.12819673120975494,
0.3614215850830078,
0.08156327903270721,
0.132633239030838,
0.9626837968826294,
0.1417873203754425,
0.2397555261850357,
... |
func (d *Dialer) EXISTS(keys ...string) (int64, error) {
result, err := d.Resp.cmd(append([]string{"EXISTS"}, keys...))
if err != nil {
return 0, err
}
return result.(int64), nil
} | [
-1.8179943561553955,
0.10430609434843063,
0.8361408114433289,
-0.4232001006603241,
0.4497257173061371,
-0.34312310814857483,
-1.0880184173583984,
-0.3684855103492737,
-0.12021541595458984,
-0.29663071036338806,
-0.34547701478004456,
-0.12444104999303818,
-0.8133784532546997,
0.058548696339... |
func (d *Dialer) DEL(keys ...string) (int64, error) {
result, err := d.Resp.cmd(append([]string{"DEL"}, keys...))
if err != nil {
return 0, err
}
return result.(int64), nil
} | [
-0.6465811133384705,
0.9159265756607056,
0.730949342250824,
-0.2445662021636963,
-0.30217957496643066,
-0.14539383351802826,
-0.4680704176425934,
-0.20946910977363586,
0.2797548472881317,
-0.33456704020500183,
-0.16224636137485504,
0.07097673416137695,
-1.1310946941375732,
-0.1569981426000... |
func (d *Dialer) SADD(key string, member ...string) (int64, error) {
result, err := d.Resp.cmd(append([]string{"SADD", key}, member...))
if err != nil {
return 0, err
}
return result.(int64), nil
} | [
-0.6440861225128174,
0.28084850311279297,
0.6780465841293335,
0.1518767923116684,
-0.044422946870326996,
0.4589073359966278,
-0.8753300905227661,
-0.2822050452232361,
0.3046894669532776,
-0.2562338709831238,
0.2610729932785034,
0.2762182950973511,
-1.8585278987884521,
0.9614887237548828,
... |
func (d *Dialer) SREM(key string, member ...string) (int64, error) {
result, err := d.Resp.cmd(append([]string{"SREM", key}, member...))
if err != nil {
return 0, err
}
return result.(int64), nil
} | [
-1.046339750289917,
1.01698637008667,
0.7471873164176941,
0.3167141079902649,
-0.1518213152885437,
-0.5236260890960693,
-0.3425932824611664,
-0.37657222151756287,
-0.02584908716380596,
0.8344109058380127,
-1.0046472549438477,
-0.36237356066703796,
-2.288923978805542,
-0.43658140301704407,
... |
func (d *Dialer) ZADD(key string, score int, member string) (int64, error) {
result, err := d.Resp.cmd([]string{"ZADD", key, strconv.Itoa(score), member})
if err != nil {
return 0, err
}
return result.(int64), nil
} | [
-0.7210093140602112,
-0.2364441603422165,
0.617538332939148,
-0.4387332797050476,
0.02220577746629715,
0.511819064617157,
-0.09500591456890106,
-0.8079604506492615,
0.6840817332267761,
0.42936012148857117,
0.22169554233551025,
0.4757528603076935,
-1.8096568584442139,
0.0017305115470662713,... |
func (d *Dialer) ZRANGE(key string, start int, stop int, WITHSCORES bool) ([]interface{}, error) {
cmd := []string{"ZRANGE", key, strconv.Itoa(start), strconv.Itoa(stop)}
if WITHSCORES {
cmd = append(cmd, "WITHSCORES")
}
result, err := d.Resp.cmd(cmd)
return result.([]interface{}), err
} | [
-1.6964714527130127,
-0.01222061924636364,
0.5270478129386902,
0.0650223046541214,
-0.1468256711959839,
-0.7321027517318726,
-0.10461317002773285,
-1.0498188734054565,
-0.46871742606163025,
0.5333218574523926,
-0.38849887251853943,
-0.05957318842411041,
-1.054153561592102,
0.08576801419258... |
func (d *Dialer) ZRANGEBYSCORE(key string, min string, max string, WITHSCORES bool, LIMIT []int) ([]interface{}, error) {
cmd := []string{"ZRANGEBYSCORE", key, min, max}
if WITHSCORES {
cmd = append(cmd, "WITHSCORES")
}
if LIMIT != nil {
if len(LIMIT) != 2 {
return nil, errors.New("LIMIT length should be 2 [... | [
-1.2734215259552002,
-0.2713073492050171,
0.925877034664154,
0.3106887638568878,
0.2572621703147888,
-1.01335871219635,
-0.26532137393951416,
-1.1809126138687134,
-0.37196117639541626,
0.9486886858940125,
-0.6412554383277893,
0.7905042171478271,
-0.7909232378005981,
-0.35351601243019104,
... |
func (d *Dialer) LPUSH(key string, values ...string) (int64, error) {
result, err := d.Resp.cmd(append([]string{"LPUSH", key}, values...))
if err != nil {
return 0, err
}
return result.(int64), nil
} | [
-0.5736450552940369,
1.0104612112045288,
0.6245076656341553,
-0.7542398571968079,
-0.25944405794143677,
0.3875144124031067,
-0.5776676535606384,
-0.7882236242294312,
0.6278541088104248,
0.041755832731723785,
0.060706403106451035,
-0.2453111708164215,
-0.7133927345275879,
0.5884115695953369... |
func (d *Dialer) LTRIM(key string, start int, stop int) (string, error) {
cmd := []string{"LTRIM", key, strconv.Itoa(start), strconv.Itoa(stop)}
result, err := d.Resp.cmd(cmd)
if err != nil {
return "", err
}
return result.(string), nil
} | [
-0.5895463824272156,
-0.029625102877616882,
0.7010319828987122,
-0.7985406517982483,
-0.38628435134887695,
-0.08886293321847916,
-1.2408549785614014,
-1.1662929058074951,
-0.05570056661963463,
0.2701522707939148,
-0.401591956615448,
0.6682516932487488,
-0.6712841987609863,
-0.7339839935302... |
func (d *Dialer) LRANGE(key string, start int, stop int) ([]interface{}, error) {
cmd := []string{"LRANGE", key, strconv.Itoa(start), strconv.Itoa(stop)}
result, err := d.Resp.cmd(cmd)
if err != nil {
return nil, err
}
return result.([]interface{}), nil
} | [
-1.6389539241790771,
-0.06695013493299484,
0.6249554753303528,
-0.4445250332355499,
-0.37974652647972107,
-0.30894964933395386,
-1.0581715106964111,
-0.5184504985809326,
-0.5184422731399536,
0.8906765580177307,
-0.37483665347099304,
-0.25526198744773865,
-0.5610137581825256,
0.533255338668... |
func (d *Dialer) HINCRBY(key string, field string, incr int) (int, error) {
cmd := []string{"HINCRBY", key, field, strconv.Itoa(incr)}
result, err := d.Resp.cmd(cmd)
if err != nil {
return -1, err
}
return result.(int), nil
} | [
-0.13394814729690552,
0.5950579643249512,
0.8867676854133606,
0.4614080786705017,
-0.40514054894447327,
-0.5499604940414429,
0.39454248547554016,
-0.7250869274139404,
-0.9955950379371643,
0.32123836874961853,
-0.31952086091041565,
0.6475356221199036,
-1.0597114562988281,
0.5524921417236328... |
func (d *Dialer) HSET(key string, field string, val interface{}) (int, error) {
cmd := []string{"HSET", key, field, fmt.Sprint(val)}
result, err := d.Resp.cmd(cmd)
if err != nil {
return -1, err
}
return result.(int), nil
} | [
-0.7988633513450623,
1.3030301332473755,
0.6193567514419556,
0.13436715304851532,
-0.45835959911346436,
-0.2343403548002243,
-0.29406389594078064,
-0.7541976571083069,
-0.6820303201675415,
0.2878665030002594,
-0.05589527636766434,
0.5012190341949463,
-0.9014650583267212,
0.0093278791755437... |
func (d *Dialer) SET(key string, val string, other ...string) (interface{}, error) {
return d.Resp.cmd(append([]string{"SET", key, val}, other...))
} | [
-1.3260983228683472,
0.2867787778377533,
0.41727641224861145,
0.1443990170955658,
-0.05526797100901604,
-0.1675073206424713,
-1.0647757053375244,
-1.657745599746704,
-0.011419222690165043,
0.060399461537599564,
-0.41887977719306946,
-0.18343469500541687,
-0.4843434691429138,
0.763405084609... |
func NewDynamicUUIDProvider() UUIDProvider {
return &dynamicUUIDProvider{}
} | [
-0.7545157074928284,
0.12546342611312866,
-0.11578984558582306,
0.47997862100601196,
-0.8694857954978943,
-0.3490844666957855,
0.11879565566778183,
0.3664650022983551,
-0.11574138700962067,
0.19672301411628723,
-0.5184758305549622,
0.28032347559928894,
-0.48344945907592773,
-0.382090210914... |
func (*dynamicUUIDProvider) New() string {
return uuid.New()
} | [
-0.6317712068557739,
-0.61174476146698,
0.2498733252286911,
0.021790310740470886,
-1.210716962814331,
0.2689616084098816,
0.17577069997787476,
0.615400493144989,
-0.11326198279857635,
0.20067286491394043,
-0.013442829251289368,
-0.09962370991706848,
-0.13364645838737488,
-0.511958479881286... |
func NewStaticUUIDProvider(staticID string) UUIDProvider {
return &staticUUIDProvider{
staticID: staticID,
}
} | [
-0.6999378800392151,
-0.20103682577610016,
-0.27061015367507935,
-0.08431036025285721,
-1.270853877067566,
0.09109503775835037,
-0.2435336858034134,
-0.008021029643714428,
0.3310421109199524,
0.8767458200454712,
-0.508073091506958,
0.08007316291332245,
-0.1925400048494339,
-0.5203961730003... |
func (s *staticUUIDProvider) New() string {
return s.staticID
} | [
-0.6206158399581909,
-0.6277832388877869,
-0.005945990327745676,
-0.05964061990380287,
-1.3117742538452148,
0.5577053427696228,
0.009357496164739132,
0.5072743892669678,
0.4056970477104187,
0.8815245032310486,
-0.32788532972335815,
0.2655509114265442,
0.3039378225803375,
-0.578562021255493... |
func Resource(resource string) schema.GroupResource {
return SchemeGroupVersion.WithResource(resource).GroupResource()
} | [
0.045066703110933304,
-0.18531566858291626,
0.09632571041584015,
-0.20158524811267853,
-1.4771199226379395,
0.4171714186668396,
0.5417071580886841,
-0.17457155883312225,
0.8170489072799683,
0.09408878535032272,
0.524219274520874,
0.7656010389328003,
0.14243637025356293,
-0.2221208214759826... |
func addKnownTypes(scheme *runtime.Scheme) error {
scheme.AddKnownTypes(
SchemeGroupVersion,
&RadixApplication{},
&RadixApplicationList{},
&RadixDeployment{},
&RadixDeploymentList{},
&RadixRegistration{},
&RadixRegistrationList{},
&RadixJob{},
&RadixJobList{},
&RadixEnvironment{},
&RadixEnvironme... | [
0.04260310158133507,
-0.07682900875806808,
0.46735167503356934,
-0.19741758704185486,
1.0101823806762695,
0.058064162731170654,
0.2338825762271881,
0.1469351351261139,
-0.09812930971384048,
0.2270043045282364,
-0.48148027062416077,
0.6874812245368958,
0.1617189347743988,
1.1614303588867188... |
func Calculate(max int) {
marked := make(map[int]bool)
p := 2 // let p = the first prime number
// starting from p-squared, count up in increments of p and
// mark each of these numbers which is greater than p-squared.
// repeat this process for all numbers greater than p which have not been marked
for j := p... | [
-0.8610510230064392,
0.1628289371728897,
0.8224805593490601,
-0.18480154871940613,
-0.16032001376152039,
-0.11834020167589188,
0.6914954781532288,
0.19950425624847412,
-0.06575685739517212,
0.5161255598068237,
-1.7996317148208618,
-0.050740305334329605,
0.0868082121014595,
0.77794724702835... |
func TestTracePanic(t *testing.T) {
t.Parallel()
var (
line int
ok bool
)
defer func() {
if recover() != nil {
trace := stack.Trace()
// find runtime.sigpanic
panicIdx := -1
for i, c := range trace {
if c.Frame().Function == "runtime.sigpanic" {
panicIdx = i
break
}
}
... | [
1.0375300645828247,
0.05967451259493828,
0.7209954857826233,
0.3748127520084381,
0.1621646136045456,
0.027691707015037537,
0.6683317422866821,
-0.9195184111595154,
0.08012918382883072,
-0.8452123999595642,
-0.8875606656074524,
-0.5955285429954529,
-0.08080263435840607,
-0.20885322988033295... |
func BenchmarkCallerAndVFmt(b *testing.B) {
for i := 0; i < b.N; i++ {
fmt.Fprint(ioutil.Discard, stack.Caller(0))
}
} | [
1.1037447452545166,
0.576380729675293,
0.37234193086624146,
0.15499252080917358,
0.5893530249595642,
-0.20475392043590546,
0.08674398064613342,
-0.6226903796195984,
0.22784903645515442,
0.39026373624801636,
0.6098494529724121,
0.49365681409835815,
-0.26886940002441406,
1.5036463737487793,
... |
func BenchmarkRuntimeCaller(b *testing.B) {
for i := 0; i < b.N; i++ {
runtime.Caller(0)
}
} | [
-0.09780855476856232,
0.977356493473053,
0.3464272618293762,
0.05945078656077385,
0.9657291173934937,
-0.12289369851350784,
-0.02032904140651226,
-0.21636855602264404,
-0.5368330478668213,
-0.23786309361457825,
-0.32423946261405945,
0.011869649402797222,
-1.2439404726028442,
1.653583765029... |
func NewConnection() *dbs {
return &dbs{
Databases: map[DbName]dbStruct{},
mutex: sync.RWMutex{},
}
} | [
-0.13716158270835876,
0.1662159413099289,
0.13008835911750793,
-0.09448035806417465,
-0.6007731556892395,
-0.5387633442878723,
0.3185063898563385,
-0.4497467875480652,
0.5491929650306702,
-0.05127783864736557,
-0.6121845245361328,
-0.7645323872566223,
-0.8399063348770142,
-0.17108303308486... |
func (d *dbs) Close(reference interface{}) {
d.mutex.Lock()
defer d.mutex.Unlock()
if r, ok := d.Connections[reference]; ok {
for _, d := range r {
for _, c := range d {
c.Close()
}
}
}
} | [
-0.5677557587623596,
0.6670697927474976,
0.6370863318443298,
-0.6635835766792297,
-0.13837262988090515,
0.019324682652950287,
0.22568798065185547,
-1.355087161064148,
-0.15965978801250458,
0.34714049100875854,
0.6449226140975952,
0.11632893234491348,
-1.5066512823104858,
1.2457457780838013... |
func (d *dbs) Get(reference interface{}, name DbName, master bool) interface{} {
d.mutex.Lock()
defer d.mutex.Unlock()
if _db, ok := d.Databases[name]; ok {
if d.Connections == nil {
d.Connections = map[interface{}]map[DbName]map[bool]dbConn{}
}
_r, _ := d.Connections[reference]
if _r == nil {
d.Con... | [
-0.5302659273147583,
0.05735357850790024,
1.1470130681991577,
-1.0139305591583252,
-0.10241929441690445,
-0.5553054809570312,
-0.21404419839382172,
0.01668335311114788,
0.043256618082523346,
0.5832065343856812,
0.09300267696380615,
1.0334498882293701,
-1.1854480504989624,
0.042782157659530... |
func (d *dbs) Set(db Db) error {
d.mutex.Lock()
defer d.mutex.Unlock()
log.Print("---- The postgresql database set 01")
if db == nil || !db.Loaded() {
return fmt.Errorf("The database could not be loaded")
}
name := db.GetName()
_dbs := d.Databases[name]
log.Print("---- The postgresql datab... | [
-0.7557810544967651,
0.9964762926101685,
0.4670160412788391,
-0.7558174133300781,
-0.2152540385723114,
0.44779032468795776,
0.23171329498291016,
-0.1092878207564354,
-0.00916116964071989,
0.04673543572425842,
-1.0161945819854736,
0.5753294229507446,
-0.7105557918548584,
0.7971982955932617,... |
func (config *IDConfig) ExampleConfig() string {
return `[id.config]
#####################
## Required Fields ##
#####################
# Index of the snapshot to be analyzed.
Snap = 100
# List of IDs to analyze.
IDs = 10, 11, 12, 13, 14
#####################
## Optional Fields ##
#####################
# IDType ind... | [
-0.1159910261631012,
-0.2903079390525818,
0.6278718113899231,
-0.4737873077392578,
-0.8024922013282776,
-0.10676001012325287,
0.19790251553058624,
0.3880886435508728,
0.17079764604568481,
0.2707327902317047,
-1.2888081073760986,
0.4451673626899719,
0.03246235102415085,
0.2675883173942566,
... |
func (config *IDConfig) ReadConfig(fname string, flags []string) error {
vars := parse.NewConfigVars("id.config")
vars.String(&config.idType, "IDType", "m200m")
vars.Ints(&config.ids, "IDs", []int64{})
vars.Int(&config.idStart, "IDStart", -1)
vars.Int(&config.idEnd, "IDEnd", -1)
vars.Int(&config.mult, "Mult", 1)... | [
0.1220446452498436,
-0.5519126057624817,
1.028164029121399,
0.3567652702331543,
-0.46277934312820435,
0.37718889117240906,
0.38289234042167664,
0.7513530254364014,
-0.628966748714447,
0.35498711466789246,
-0.3505297899246216,
-0.11328084021806717,
-0.3534661531448364,
0.6687848567962646,
... |
func (config *IDConfig) validate() error {
switch config.idType {
case "halo-id", "m200m":
default:
return fmt.Errorf("The 'IDType' variable is set to '%s', which I "+
"don't recognize.", config.idType)
}
switch config.exclusionStrategy {
case "none", "subhalo", "neighbor":
case "overlap":
if config.excl... | [
-0.26998084783554077,
-0.26788240671157837,
0.644517183303833,
0.09062431007623672,
-0.3029777705669403,
0.3767075836658478,
-0.07731099426746368,
-0.4765923321247101,
-0.10100359469652176,
0.15103453397750854,
-0.16243977844715118,
0.08136477321386337,
-0.7810216546058655,
0.7131671309471... |
func (config *IDConfig) Run(
gConfig *GlobalConfig, e *env.Environment, stdin []byte,
) ([]string, error) {
if logging.Mode != logging.Nil {
log.Println(`
##################
## shellfish id ##
##################`,
)
}
var t time.Time
if logging.Mode == logging.Performance {
t = time.Now()
}
if config.sna... | [
-1.0211950540542603,
-0.17482854425907135,
1.0079058408737183,
-0.09708729386329651,
-0.14875204861164093,
0.08719301223754883,
0.4289131462574005,
-0.31755775213241577,
-0.12026964128017426,
0.8296830058097839,
-1.19033944606781,
0.5582252740859985,
-0.37225133180618286,
0.448320478200912... |
func getMassIDRange(
gConfig *GlobalConfig, e *env.Environment, config *IDConfig,
vars *halo.VarColumns,
) error {
config.idType = "m200m"
buf, err := getVectorBuffer(
e.ParticleCatalog(int(config.snap), 0), gConfig,
)
if err != nil { return err }
rids, err := memo.ReadSortedRockstarIDs(
int(config.snap), ... | [
-0.7305639982223511,
-0.044867996126413345,
0.7034079432487488,
-0.14570410549640656,
-0.4741305410861969,
-0.2970678508281708,
-0.17112478613853455,
0.4332132041454315,
-0.5387642979621887,
0.26541417837142944,
-0.4630994498729706,
0.5592768788337708,
-1.1126292943954468,
0.36052402853965... |
func newIntFinder(rids []int) intFinder {
f := intFinder{}
f.m = make(map[int]int)
for i, rid := range rids { f.m[rid] = i }
return f
} | [
-0.8495733141899109,
-0.7225596308708191,
0.19554513692855835,
-0.5178154706954956,
-0.9412096738815308,
-0.38488084077835083,
-0.033217430114746094,
-0.34691864252090454,
-0.16430072486400604,
0.0850910022854805,
-0.2239621877670288,
-0.6372122764587402,
-0.5830215811729431,
0.20200231671... |
func (f intFinder) find(rid int) (int, bool) {
line, ok := f.m[rid]
return line, ok
} | [
-0.3193854093551636,
-0.4065767526626587,
0.4156019985675812,
-0.4391258955001831,
-0.5085594654083252,
-0.6470980048179626,
0.9067752361297607,
-0.7652386426925659,
-1.100340723991394,
0.44223687052726746,
0.05771534889936447,
-1.0463751554489136,
-0.7827056050300598,
0.6067508459091187,
... |
func (client *Client) AddRoom(key string) {
client.Lock()
client.Room[key] = true
client.Unlock()
} | [
-0.9298839569091797,
0.4153706729412079,
0.3944535255432129,
0.4154004752635956,
-0.3436882495880127,
0.9199555516242981,
-0.8611410856246948,
0.03874614089727402,
-0.025307603180408478,
0.4943816661834717,
-0.2935039699077606,
0.16277039051055908,
-1.5720824003219604,
0.6515957117080688,
... |
func (client *Client) DeleteRoom(key string) {
client.Lock()
delete(client.Room, key)
client.Unlock()
} | [
-0.5215469002723694,
0.4012612998485565,
0.10155365616083145,
0.7323971390724182,
-0.3188513219356537,
0.03325391560792923,
-0.5076233744621277,
-0.08690118789672852,
-0.020718805491924286,
0.19852419197559357,
-0.03093855455517769,
0.7574004530906677,
-1.2766226530075073,
0.18547080457210... |
func (c *Client) Consume() {
// if function finish, remove client
// and also close connection
defer func() {
c.Manager.Unregister <- c
c.Conn.Close()
}()
c.Conn.SetReadLimit(MaxMessageSize)
c.Conn.SetReadDeadline(time.Now().Add(PongWait))
c.Conn.SetPongHandler(func(string) error {
c.Conn.SetReadDeadline... | [
0.20250281691551208,
-0.5559251308441162,
1.1063151359558105,
-0.18469661474227905,
-0.320103257894516,
-0.24466873705387115,
0.18432895839214325,
-0.5266648530960083,
-0.49004462361335754,
0.8830204010009766,
0.4273371696472168,
0.6889804005622864,
-0.24625210464000702,
1.0897128582000732... |
func (c *Client) Publish() {
ticker := time.NewTicker(PingPeriod)
defer func() {
ticker.Stop()
c.Conn.Close()
}()
for {
select {
case msg, ok := <-c.MsgChan:
c.Conn.SetWriteDeadline(time.Now().Add(WriteWait))
if !ok {
// manager closed the send channel.
c.Conn.WriteMessage(websocket.CloseMe... | [
-0.6542598009109497,
-0.07955168932676315,
0.7800482511520386,
0.019190102815628052,
0.20180237293243408,
-0.15119466185569763,
0.8131842017173767,
-0.6527211666107178,
-1.001457691192627,
-0.009104736149311066,
0.430955171585083,
-0.049502674490213394,
-0.6615984439849854,
0.9568057656288... |
func isValidURL(toTest string) bool {
_, err := url.ParseRequestURI(toTest)
if err != nil {
return false
}
u, err := url.Parse(toTest)
if err != nil || u.Scheme == "" || u.Host == "" {
return false
}
return true
} | [
-0.43104198575019836,
0.252188503742218,
0.5944400429725647,
0.5816640257835388,
0.010748257860541344,
0.8197724223136902,
-0.17801594734191895,
0.2201802283525467,
0.7255489230155945,
-0.9612334966659546,
0.5635747313499451,
0.31718090176582336,
-0.8309463858604431,
0.47646811604499817,
... |
func BenchmarkSegmentID(b *testing.B) {
rowID := RandomRowid()
b.Run("BorrowSegmentID", func(b *testing.B) {
var ret *Segmentid
for i := 0; i < b.N; i++ {
ret = rowID.BorrowSegmentID()
}
globalSegmentidPointer = ret
})
b.Run("CloneSegmentID", func(b *testing.B) {
var ret Segmentid
for i := 0; i < b... | [
-0.14642015099525452,
0.3938754200935364,
0.5370944142341614,
0.14686159789562225,
1.2592474222183228,
0.24344754219055176,
1.4707697629928589,
-0.7186368107795715,
0.837269127368927,
0.6679872870445251,
-0.1759878545999527,
0.7282054424285889,
-0.9274821281433105,
0.5844159126281738,
-0... |
func ReadPropertyfile(filepath string) {
propertyFile = []string{filepath}
props, _ = properties.LoadFiles(propertyFile, properties.UTF8, true)
} | [
0.45186886191368103,
-1.1044319868087769,
0.4899331033229828,
0.08294317871332169,
0.015375128015875816,
0.9849786758422852,
0.118838369846344,
0.6645267009735107,
-0.6903182864189148,
0.7898670434951782,
0.849958598613739,
-0.43143385648727417,
-0.2616158425807953,
-0.7560674548149109,
... |
func JSONToStruct(data []byte, datastruct interface{}) error {
return json.Unmarshal(data, &datastruct)
} | [
-0.6761218905448914,
-0.43325600028038025,
0.491060733795166,
-1.9654343128204346,
-1.374444842338562,
-0.4598357677459717,
-0.6968510746955872,
-1.0069382190704346,
0.8133882880210876,
-0.42053157091140747,
-1.250512719154358,
0.6579679846763611,
0.528330385684967,
-0.40113040804862976,
... |
func WriteResponseMessage(w http.ResponseWriter, status int, responseText []byte) {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(status)
if len(responseText) > 0 {
w.Write(responseText)
}
} | [
-1.0046639442443848,
-0.4421490430831909,
0.3758027255535126,
-0.17414966225624084,
0.776978611946106,
-0.7022148370742798,
-0.06757647544145584,
-0.47196272015571594,
0.41387948393821716,
-0.1872643083333969,
-1.1486968994140625,
-0.7911113500595093,
-0.4423653781414032,
0.455564200878143... |
func GetProperty(propertyName string, params ...string) string {
msg, ok := props.Get(propertyName)
if !ok {
return props.MustGet("Property is not available in property file for key " + propertyName)
}
placehdrCnt := strings.Count(msg, "{")
if placehdrCnt == len(params) {
for i, val := range params {
repalc... | [
-0.4779704213142395,
-0.6486620306968689,
0.9007889032363892,
0.07513263076543808,
0.7951000928878784,
-0.016172798350453377,
0.29117143154144287,
0.4138416349887848,
-0.6779332160949707,
0.8307970762252808,
1.3465816974639893,
0.13797259330749512,
-0.5782363414764404,
0.4794155955314636,
... |
func IsString(k interface{}) bool {
switch k.(type) {
case string:
if len(strings.TrimSpace(k.(string))) <= 0 {
return false
}
return true
default:
return false
}
} | [
-0.9629208445549011,
0.44525977969169617,
0.4389503598213196,
0.8327128291130066,
-0.13949911296367645,
0.5516125559806824,
-0.13589046895503998,
0.1324280947446823,
0.7977680563926697,
0.8563410043716431,
-0.16508416831493378,
-0.33151793479919434,
-0.6050970554351807,
0.8117668628692627,... |
func (th *taskManager) Listen(stop chan bool) {
//init node list
th.initializeNodes()
logging.Log("Listening TM")
for {
select {
case <-stop:
//stop <- true
th.Shutdown()
return
case <-th.jobchan:
//Grab first task
for job := range th.tasks.IterBuffered() {
//time.Sleep(5 * time.Microsecon... | [
0.03296871483325958,
-0.3200383484363556,
0.5780833959579468,
-0.867081344127655,
0.10860911756753922,
0.4693886339664459,
0.3610515296459198,
0.2829780578613281,
-0.8549326658248901,
0.2530820667743683,
-0.6768842339515686,
-0.7882391810417175,
0.3536251485347748,
1.0133408308029175,
-0... |
func (th *taskManager) AddJob(name string, applicationid string,
containerid string, newname string, nodeid string) {
newjob := &Task{}
jobid := uuid.NewV4().String()
newjob.JobID = jobid
newjob.Name = name
newjob.ApplicationID = applicationid
newjob.ContainerID = containerid
newjob.NewName = newname
newjob.... | [
0.3181367516517639,
-0.20682059228420258,
0.6103211045265198,
0.6894841194152832,
-0.08190616220235825,
0.48682335019111633,
-0.6258389949798584,
0.0838642343878746,
-0.7071910500526428,
-0.10603263974189758,
-0.4579770267009735,
-0.12169048190116882,
-0.3161619007587433,
0.487439423799514... |
func FeatureContextQueueEvent(s *godog.Suite) {
test := new(alertTest)
s.BeforeScenario(test.startConsume)
s.Step(`^I CreateEvent with EventRequest to service API with OccursAt = Now$`,
test.iCreateEventWithEventRequestToServiceAPIWithOccursAtNow)
s.Step(`^added event will be scheduled into message queue$`,
te... | [
0.3769954442977905,
-0.5519981384277344,
0.8968870639801025,
0.7285613417625427,
0.895258367061615,
-0.5098913311958313,
0.34871214628219604,
-0.340716153383255,
-0.026893265545368195,
0.19604334235191345,
-0.03726092353463173,
1.112363338470459,
0.3844652771949768,
0.5025421380996704,
0... |
func NopReplicationCallback(idx int) error {
return nil
} | [
-0.7398847341537476,
0.8994907736778259,
0.34582045674324036,
-0.16298441588878632,
-0.8549549579620361,
-0.07045624405145645,
1.1457571983337402,
0.6958251595497131,
1.070326328277588,
-0.14474892616271973,
-0.3542729318141937,
-0.572449266910553,
0.12219414114952087,
0.5382166504859924,
... |
func Open(backend Backend) (*Storage, error) {
s := new(Storage)
s.backend = backend
err := s.readHeader()
if err != nil {
log.Errorf("error reading storage header: %s", err)
return nil, err
}
return s, nil
} | [
0.11274605244398117,
-0.20838551223278046,
0.3830273747444153,
0.4424954354763031,
-0.8607990145683289,
0.12871085107326508,
-0.10915406793355942,
0.07794828712940216,
-0.7986640334129333,
0.07020776718854904,
-0.33420130610466003,
-0.3168441951274872,
-0.6732943654060364,
-0.7729852795600... |
func (s *Storage) WriteTo(data []byte, idx int, callback ReplicationCallback) (int, error) {
plainDataLength := len(data)
log.Debugf("data size is %d", plainDataLength)
buf, err := zip(data)
gzipped := true
if err != nil {
log.Errorf("error compressing data: %s", err)
return -1, common.NewHTTPError(500, "error... | [
-0.7762458324432373,
0.7607406377792358,
0.7068868279457092,
-0.832194447517395,
0.15138937532901764,
-0.8574773073196411,
0.6319659352302551,
-0.6231067776679993,
-0.0906551331281662,
-0.12753815948963165,
-0.43014806509017944,
0.35460707545280457,
-0.5081754326820374,
-0.2251076251268386... |
func (s *Storage) Write(data []byte, callback ReplicationCallback) (int, error) {
return s.WriteTo(data, -1, callback)
} | [
-0.8305051922798157,
0.9013969898223877,
0.22426074743270874,
0.6368557214736938,
0.4271576404571533,
-0.7003180980682373,
0.8524904251098633,
0.7261901497840881,
0.777174711227417,
0.0496545247733593,
-0.8323018550872803,
0.1480875313282013,
-0.7903346419334412,
0.0360599085688591,
0.72... |
func (s *Storage) GetID() uint64 {
return s.header.StorageID
} | [
0.6621609926223755,
-0.23611678183078766,
0.555033266544342,
1.4346486330032349,
0.5025006532669067,
0.03354200720787048,
0.4218144416809082,
-0.3308562934398651,
1.048912525177002,
-0.48461267352104187,
-0.5943316221237183,
-0.5254777073860168,
-0.7235214710235596,
0.762734055519104,
0.... |
func (s *Storage) GetChunkSize() int {
return int(s.header.ChunkSize)
} | [
0.05564560368657112,
0.13570204377174377,
0.6773533821105957,
0.49936217069625854,
0.02778308466076851,
-0.9920645356178284,
0.2814527153968811,
0.14286507666110992,
-0.7589901685714722,
-0.894923746585846,
-0.31484946608543396,
0.6288511753082275,
-0.511829674243927,
0.2276456654071808,
... |
func (s *Storage) GetNumChunks() int {
return int(s.header.NumChunks)
} | [
0.2762746810913086,
0.15912750363349915,
0.5000064373016357,
0.5386894345283508,
0.42584696412086487,
-1.1921987533569336,
0.1801799237728119,
-0.23882260918617249,
-0.6851946115493774,
-0.921863853931427,
-0.9567402601242065,
0.4111165702342987,
-0.047362715005874634,
0.18442364037036896,... |
func (s *Storage) GetChunkDataSize() int {
return int(s.header.ChunkSize) - chunkHeaderSize
} | [
0.5035827159881592,
-0.13977360725402832,
0.5918752551078796,
-0.5849548578262329,
-0.24639125168323517,
-0.00896845106035471,
-0.35942426323890686,
-0.07934316247701645,
-0.9123107194900513,
-0.8398760557174683,
-0.6714550852775574,
1.15079665184021,
-0.4336436986923218,
0.015207959339022... |
func (s *Storage) IsFull() bool {
s.locker.RLock()
defer s.locker.RUnlock()
return s.header.FreeChunkIdx >= s.header.NumChunks
} | [
0.6148747801780701,
-0.14381036162376404,
0.5914496779441833,
0.34695887565612793,
-0.15884394943714142,
-0.8257405161857605,
-0.32895907759666443,
-0.40859127044677734,
-0.07473769038915634,
0.28870218992233276,
-1.0327867269515991,
-0.16012847423553467,
-0.15111365914344788,
-0.294252932... |
func (s *Storage) Iter(callback IterationCallback) error {
var data []byte
s.locker.RLock()
defer s.locker.RUnlock()
idx := 0
for idx < int(s.header.FreeChunkIdx) {
buf, length, gzipped, err := s.readRaw(idx)
if err != nil {
return err
}
if gzipped {
data, err = unzip(buf)
if err != nil {
re... | [
-0.09208377450704575,
0.1140432208776474,
0.5475804805755615,
-0.10485826432704926,
-0.026494186371564865,
-0.06511953473091125,
0.760674774646759,
-0.7210453748703003,
-0.5450803637504578,
0.17097558081150055,
0.20544391870498657,
-0.39204105734825134,
-0.003073548199608922,
0.34562227129... |
func NewDB(config Config, metrics metrics.Metrics) SqlDB {
return &sqlDB{
config: config,
log: metrics,
}
} | [
1.3299540281295776,
0.7048298120498657,
0.512478232383728,
1.3866207599639893,
-0.88564133644104,
0.947295606136322,
-0.07668409496545792,
-0.24799978733062744,
0.32097873091697693,
0.06758715957403183,
1.141455054283142,
-0.14673404395580292,
-0.029161786660552025,
-0.014639503322541714,
... |
func (dl sqlDB) New() (*sqlx.DB, error) {
if dl.config.Host == "" {
dl.config.Host = "0.0.0.0"
}
addr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s", dl.config.User, dl.config.Password, dl.config.Host, dl.config.Port, dl.config.DB)
db, err := sqlx.Connect(dl.config.Driver, addr)
if err != nil {
dl.log.Emit(metrics.Erro... | [
-0.11235344409942627,
0.08551954478025436,
0.7067215442657471,
-0.05453304201364517,
-0.8619353175163269,
0.2725672423839569,
-0.9232029914855957,
0.3090634346008301,
-0.7925118207931519,
0.024098601192235947,
0.23911692202091217,
-0.13489891588687897,
0.023150751367211342,
0.4579281210899... |
func Exec(ctx context.Context, m metrics.Metrics, db SqlDB, fx func(*sqlx.DB) error) error {
defer m.CollectMetrics("DB.Exec")
if isContextExpired(ctx) {
err := ErrExpiredContext
m.Emit(metrics.Errorf("Failed to execute operation"), metrics.With("error", err.Error()))
return err
}
sx, err := db.New()
if er... | [
0.4553709030151367,
1.8106554746627808,
1.064305067062378,
0.47734126448631287,
-0.6418041586875916,
-0.02079867385327816,
-0.18867914378643036,
-0.09909811615943909,
-0.7100323438644409,
0.5381786823272705,
0.23321180045604706,
0.08123096078634262,
0.7060517072677612,
-0.24959182739257812... |
func main() {
r := mux.NewRouter()
r.HandleFunc("/articles/{id}", GetArticleByIdHandler()).Methods("GET")
r.HandleFunc("/articles/{id}", PutArticleHandler()).Methods("PUT")
r.HandleFunc("/articles", PostArticleHandler()).Methods("POST")
r.HandleFunc("/tags/{tagName}/{date}", GetArticlesByTagDateHandler()).Methods(... | [
0.10762541741132736,
0.16909807920455933,
0.7068740725517273,
0.5659892559051514,
0.5795040726661682,
0.11935065686702728,
0.5999857783317566,
0.24144074320793152,
-1.2286736965179443,
-0.7111778855323792,
-0.13499441742897034,
-0.18313060700893402,
0.8648573756217957,
-0.5419492721557617,... |
func (m *Http404Error) Validate(formats strfmt.Registry) error {
var res []error
if err := m.validateResource(formats); err != nil {
// prop
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | [
-0.4010818600654602,
-0.19610288739204407,
0.10472526401281357,
0.011203976348042488,
1.1765375137329102,
0.2940114438533783,
0.7563250660896301,
0.2028554230928421,
-0.7839758992195129,
0.6127505302429199,
0.5740793943405151,
0.12008693814277649,
-1.342114806175232,
0.7485133409500122,
... |
func (e *EndToEndTest) RunTitanDocker(entryPoint string, daemon bool) error {
args := []string{"run", "--privileged", "--pid=host", "--network=host",
"-v", "/var/lib:/var/lib", "-v", "/run/docker:/run/docker"}
if daemon {
args = append(args, "-d", "--restart", "always", "--name", e.GetPrimaryContainer(),
"-v",... | [
-0.1449926495552063,
-1.2047028541564941,
0.9732444286346436,
-0.36088618636131287,
0.3777308166027069,
-0.20506775379180908,
0.38330286741256714,
0.11378844082355499,
-0.5101297497749329,
0.4509204030036926,
0.570163905620575,
0.5386705994606018,
-0.2328273355960846,
0.38602885603904724,
... |
func (e *EndToEndTest) RunTitanKubernetes(entryPoint string, parameters ...string) error {
imageSpecified := false
for _, p := range parameters {
if strings.Index(p, "titanImage=") == 0 {
imageSpecified = true
break
}
}
if !imageSpecified {
image := os.Getenv("TITAN_IMAGE")
if image == "" {
image =... | [
-0.5647386312484741,
-1.1434270143508911,
0.8057900667190552,
-0.2459307312965393,
0.7329893112182617,
-0.04482467100024223,
0.09638067334890366,
-0.019056113436818123,
-0.5693769454956055,
0.9624324440956116,
0.682135820388794,
0.10964850336313248,
-0.4508931636810303,
0.0190157201141119,... |
func (e *EndToEndTest) StartServer(parameters ...string) error {
err := exec.Command("docker", "volume", "create", fmt.Sprintf("%s-data", e.Identity)).Run()
if err != nil {
return err
}
if e.Context == "docker-zfs" {
return e.RunTitanDocker("launch", true)
} else {
return e.RunTitanKubernetes("run", paramete... | [
-0.6806884407997131,
-0.6499205231666565,
0.5349690318107605,
0.9695422649383545,
1.2353131771087646,
0.4112466871738434,
0.3757820725440979,
0.16909165680408478,
-0.0021911300718784332,
-0.23538054525852203,
0.5031532645225525,
0.26702478528022766,
-0.6704180240631104,
0.5937227606773376,... |
func (e *EndToEndTest) GetContainer(t string) string {
return fmt.Sprintf("%s-%s", e.Identity, t)
} | [
0.06501266360282898,
-0.6006007194519043,
0.2301398664712906,
-0.6716092824935913,
1.081573724746704,
0.5713200569152832,
0.1994919329881668,
-0.5335713624954224,
-0.08941680938005447,
0.10963383316993713,
0.8002415895462036,
-0.039718616753816605,
0.4422103762626648,
0.636680006980896,
... |
func (e *EndToEndTest) GetPrimaryContainer() string {
var containerType string
if e.Context == "docker-zfs" {
containerType = "launch"
} else {
containerType = "server"
}
return e.GetContainer(containerType)
} | [
0.324779748916626,
0.016064487397670746,
0.7202349901199341,
0.3158662021160126,
0.5280113220214844,
-0.8351500034332275,
0.324645072221756,
-0.8910189867019653,
0.951166570186615,
-1.0091769695281982,
0.9418357014656067,
1.2377967834472656,
-0.01865735650062561,
1.8163937330245972,
0.24... |
func (e *EndToEndTest) WaitForServer() error {
success := false
tried := 1
for ok := true; ok; ok = !success {
_, _, err := e.Client.RepositoriesApi.ListRepositories(context.Background())
if err == nil {
success = true
} else {
tried++
if tried == waitRetries {
logs, err := exec.Command("docker", ... | [
-0.4227443039417267,
0.7777144312858582,
0.5305606722831726,
-0.661641001701355,
1.044089913368225,
0.07652296125888824,
0.09558962285518646,
-0.09307446330785751,
-0.30078741908073425,
-0.4934389889240265,
-0.04789160564541817,
0.38483351469039917,
-0.5612837076187134,
0.4417228698730469,... |
func (e *EndToEndTest) RestartServer() error {
return exec.Command("docker", "rm", "-f", e.GetContainer("server")).Run()
} | [
-0.5571641325950623,
0.2927207052707672,
0.5385817289352417,
0.00837132427841425,
1.4279180765151978,
-0.31275683641433716,
1.1035159826278687,
0.812519907951355,
-0.21192842721939087,
-0.2243916541337967,
-0.3079932928085327,
0.9259923100471497,
-0.6589595675468445,
0.3467288613319397,
... |
func (e *EndToEndTest) StopServer(ignoreErrors bool) error {
if e.Context == "docker-zfs" {
err := exec.Command("docker", "rm", "-f", e.GetContainer("launch")).Run()
if err != nil && !ignoreErrors {
return err
}
}
err := exec.Command("docker", "rm", "-f", e.GetContainer("server")).Run()
if err != nil && !i... | [
-1.10618257522583,
-0.5610397458076477,
0.9423852562904358,
0.06805050373077393,
1.0146219730377197,
0.2098032683134079,
0.9584251642227173,
-0.04024655744433403,
0.28593263030052185,
-0.14273610711097717,
0.33264902234077454,
0.38827773928642273,
-0.8922132849693298,
0.5537824034690857,
... |
func (e *EndToEndTest) GetVolumePath(repo string, volume string) (string, error) {
v, _, err := e.Client.VolumesApi.GetVolume(context.Background(), repo, volume)
if err != nil {
return "", err
}
return v.Config["mountpoint"].(string), nil
} | [
0.5358848571777344,
-0.7747350931167603,
0.49508136510849,
0.7673863172531128,
0.8267161250114441,
0.0006670343573205173,
-0.2861107587814331,
-0.8372526168823242,
0.044543247669935226,
1.0472310781478882,
0.4526573419570923,
0.13930124044418335,
-1.1261615753173828,
0.22718188166618347,
... |
func (e *EndToEndTest) ExecServer(args ...string) (string, error) {
fullArgs := []string{"exec", e.GetContainer("server")}
fullArgs = append(fullArgs, args...)
out, err := exec.Command("docker", fullArgs...).Output()
if err != nil {
return "", err
}
return string(out), nil
} | [
-0.9897658824920654,
-0.030238384380936623,
0.7873228192329407,
-0.007288838736712933,
0.4850006401538849,
0.07566170394420624,
0.613935112953186,
-0.13469825685024261,
-0.3396575152873993,
-0.004787905141711235,
-0.04214031621813774,
0.5901213884353638,
-0.7958329319953918,
0.776664674282... |
func (e *EndToEndTest) WriteFile(repo string, volume string, filename string, content string) error {
mountpoint, err := e.GetVolumePath(repo, volume)
if err != nil {
return err
}
path := fmt.Sprintf("%s/%s", mountpoint, filename)
return exec.Command("docker", "exec", e.GetContainer("server"), "sh", "-c",
fmt.... | [
0.4061630964279175,
-0.31631356477737427,
0.7947070002555847,
-0.07011596858501434,
1.6603065729141235,
0.3835430443286896,
0.555022120475769,
0.3367026746273041,
-1.2918215990066528,
-0.02350790612399578,
0.9873218536376953,
0.09969139099121094,
-0.5261876583099365,
0.19219449162483215,
... |
func (e *EndToEndTest) ReadFile(repo string, volume string, filename string) (string, error) {
mountpoint, err := e.GetVolumePath(repo, volume)
if err != nil {
return "", err
}
path := fmt.Sprintf("%s/%s", mountpoint, filename)
out, err := exec.Command("docker", "exec", e.GetContainer("server"), "cat", path).Out... | [
0.5478186011314392,
-0.14146387577056885,
0.8518770933151245,
-0.15483464300632477,
0.42951154708862305,
0.18303702771663666,
0.09097792953252792,
0.07978834956884384,
-1.2340809106826782,
0.24207770824432373,
1.5434279441833496,
0.20865097641944885,
-0.4131578803062439,
-0.162990391254425... |
func (e *EndToEndTest) PathExists(path string) bool {
err := exec.Command("docker", "exec", e.GetContainer("server"), "ls", path).Run()
return err != nil
} | [
-0.3285149037837982,
-0.014015471562743187,
0.7113940715789795,
-0.009118672460317612,
1.0152497291564941,
0.6597121357917786,
0.19415263831615448,
0.1337096393108368,
0.004455299116671085,
0.1758527010679245,
-0.22978812456130981,
-0.28551435470581055,
-0.32805144786834717,
0.069860965013... |
func (e *EndToEndTest) WriteFileSsh(path string, content string) error {
return exec.Command("docker", "exec", e.GetContainer("ssh"), "sh", "-c",
fmt.Sprintf("echo \"%s\" > %s", content, path)).Run()
} | [
0.9777896404266357,
-0.44075480103492737,
0.6342378854751587,
-0.509482741355896,
1.2703109979629517,
0.8056963086128235,
0.04292043298482895,
0.23905049264431,
-1.3015336990356445,
-0.5958425998687744,
-0.17486973106861115,
0.5212985873222351,
0.27763718366622925,
0.41871798038482666,
0... |
func WithTimeFormat(timeformat string) Configurator {
return func(app *Application) {
app.config.TimeFormat = timeformat
}
} | [
0.26189255714416504,
-0.1808605194091797,
0.4165634512901306,
-0.45126593112945557,
-1.2286888360977173,
-0.6734158992767334,
-0.72373366355896,
-0.3730534613132477,
0.7411355972290039,
-0.03585929423570633,
-0.5949307084083557,
-0.916050136089325,
0.47538071870803833,
1.7149646282196045,
... |
func WithCharset(charset string) Configurator {
return func(app *Application) {
app.config.Charset = charset
}
} | [
0.4215632379055023,
-0.34949415922164917,
0.30633223056793213,
-0.9278481006622314,
-0.773931622505188,
-0.11783218383789062,
-0.2761043906211853,
-0.1731843650341034,
-0.18819423019886017,
0.17204800248146057,
-0.369125097990036,
0.10565405339002609,
1.2224388122558594,
0.3008013367652893... |
func WithRemoteAddrHeader(headerName string) Configurator {
return func(app *Application) {
if app.config.RemoteAddrHeaders == nil {
app.config.RemoteAddrHeaders = make(map[string]bool)
}
app.config.RemoteAddrHeaders[headerName] = true
}
} | [
0.2548983693122864,
-0.8424688577651978,
0.8075569272041321,
-0.7299194931983948,
-1.237784504890442,
0.6081781387329102,
-0.9148856997489929,
0.003561927704140544,
0.3767198920249939,
0.7077974081039429,
-1.0063722133636475,
-0.4755460023880005,
0.1967175453901291,
0.5993663668632507,
0... |
func WithoutRemoteAddrHeader(headerName string) Configurator {
return func(app *Application) {
if app.config.RemoteAddrHeaders == nil {
app.config.RemoteAddrHeaders = make(map[string]bool)
}
app.config.RemoteAddrHeaders[headerName] = false
}
} | [
-0.36440718173980713,
-0.7085264921188354,
0.5813945531845093,
-0.9497982859611511,
-1.7373852729797363,
1.1855429410934448,
-0.2945970594882965,
0.3418600261211395,
0.07291187345981598,
0.5423855185508728,
-0.9599257111549377,
-0.9017106890678406,
-0.7775546312332153,
0.47243690490722656,... |
func WithOtherValue(key string, val interface{}) Configurator {
return func(app *Application) {
if app.config.Other == nil {
app.config.Other = make(map[string]interface{})
}
app.config.Other[key] = val
}
} | [
-0.04127074405550957,
-0.5931642651557922,
0.6460973620414734,
-0.01283397525548935,
-1.23733651638031,
-0.009442327544093132,
-0.6770830154418945,
0.11965898424386978,
0.1511102169752121,
0.23353180289268494,
-0.17456623911857605,
-0.45677757263183594,
0.8785321116447449,
1.83444070816040... |
func New(cfg *cfg.File, backend string, productionFlag bool) (p *FeedService, err error) {
p = &FeedService{
productionFlag: productionFlag,
mux: new(sync.Mutex),
cfg: cfg,
}
p.errs = NewPE(
p.mux,
p.productionFlag,
)
p.backend, err = checkBackend(backend)
if err != nil {
retur... | [
-0.010835779830813408,
-0.06268332153558731,
0.4983271062374115,
0.30303260684013367,
-0.1760863959789276,
-0.3180050253868103,
-0.4140624701976776,
-0.5462890863418579,
-0.8549275398254395,
0.14572758972644806,
0.2133581042289734,
1.0136520862579346,
-0.4586968421936035,
0.877234160900116... |
func (p *FeedService) PurgeProducts() {
defer track(time.Now(), "FeedService")
domain, key, secret, err := p.cfg.GetWoo()
p.errs.Log(err, "Load WC Config")
_, locale, _, err := p.cfg.GetLocale()
p.errs.Log(err, "Load Locale from Config")
w, err := woo.NewWooConnection(domain, key, secret, locale)
p.errs.Log(e... | [
-0.6703869700431824,
0.19938866794109344,
0.39689603447914124,
-0.29793503880500793,
0.8787602782249451,
-0.37016430497169495,
0.11716717481613159,
-0.9159417748451233,
0.20847386121749878,
0.322598397731781,
-0.22843626141548157,
0.9785856008529663,
-0.5229043364524841,
0.7083665132522583... |
func NewMDNSClientMock(t minimock.Tester) *MDNSClientMock {
m := &MDNSClientMock{t: t}
if controller, ok := t.(minimock.MockController); ok {
controller.RegisterMocker(m)
}
m.ExchangeMock = mMDNSClientMockExchange{mock: m}
m.ExchangeMock.callArgs = []*MDNSClientMockExchangeParams{}
return m
} | [
-0.2704715430736542,
0.971703290939331,
-0.27406057715415955,
0.026658620685338974,
-1.0086759328842163,
-0.47549673914909363,
0.05857592448592186,
-0.1319427192211151,
0.7949857711791992,
-0.20520682632923126,
-0.3704501986503601,
0.48480531573295593,
-0.10594066232442856,
-0.456226438283... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.