id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c173500 | timeout)
if conn != nil {
conn.Close()
return true
}
return false
} | |
c173501 | logger.Error(err.Error())
return ErrGetEndpoint
}
endpointMsgSealed, err = data.ToBytes(rawMsg)
if err != nil {
logger.Error(err.Error())
return ErrGetEndpoint
}
}
err = w.addJobWithData(logger, nil, data.JobClientEndpointRestore,
data.JobChannel, ch.ID, &data.JobEndpointCreateData{EndpointSealed: endpointMsgSealed})
if err != nil {
return err
}
client, err := w.account(logger, ch.Client)
if err != nil {
return err
}
return w.addJob(logger, nil,
data.JobAccountUpdateBalances, data.JobAccount, client.ID)
} | |
c173502 | data.FromBytes(jdata.EndpointSealed),
PaymentReceiverAddress: raddr,
ServiceEndpointAddress: saddr,
Username: pointer.ToString(msg.Username),
Password: pointer.ToString(msg.Password),
AdditionalParams: params,
CountryStatus: pointer.ToString(countryStatus),
}
if err = w.db.Insert(&endp); err != nil {
logger.Add("endpoint", endp).Error(err.Error())
return ErrInternal
}
ch.ServiceStatus = data.ServiceSuspended
changedTime := time.Now()
ch.ServiceChangedTime = &changedTime
// TODO: Review flow with service_changed_time.
ch.PreparedAt = changedTime
err = w.saveRecord(logger, w.db.Querier, ch)
if err != nil {
logger.Error(err.Error())
return ErrInternal
}
return nil
})
} | |
c173503 |
return err
}
logger = logger.Add("channel", ch)
ch.ChannelStatus = data.ChannelClosedUncoop
if err := w.saveRecord(logger, w.db.Querier, ch); err != nil {
return err
}
client, err := w.account(logger, ch.Client)
if err != nil {
return err
}
return w.addJob(logger, nil,
data.JobAccountUpdateBalances, data.JobAccount, client.ID)
} | |
c173504 | err != nil {
logger.Error(err.Error())
return ErrTerminateChannel
}
}
client, err := w.account(logger, ch.Client)
if err != nil {
return err
}
return w.addJob(logger, nil,
data.JobAccountUpdateBalances, data.JobAccount, client.ID)
} | |
c173505 | err
}
logger = logger.Add("channel", ch)
if ch.ServiceStatus == data.ServiceActive {
ch.ServiceStatus = data.ServiceTerminating
} else {
ch.ServiceStatus = data.ServiceTerminated
}
changedTime := time.Now()
ch.ServiceChangedTime = &changedTime
err = w.saveRecord(logger, w.db.Querier, ch)
if err != nil {
return err
}
return nil
} | |
c173506 |
ch.ServiceStatus = data.ServiceSuspending
changedTime := time.Now()
ch.ServiceChangedTime = &changedTime
err = w.saveRecord(logger, w.db.Querier, ch)
if err != nil {
return err
}
return nil
} | |
c173507 | logger.Add("channel", ch)
ch.ServiceStatus = data.ServiceActivating
changedTime := time.Now()
ch.ServiceChangedTime = &changedTime
return w.saveRecord(logger, w.db.Querier, ch)
} | |
c173508 | }
offerHash, err := data.HexToHash(offer.Hash)
if err != nil {
logger.Error(err.Error())
return ErrParseOfferingHash
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
blocks, err := w.blocksTillChallangeEnd(ctx, logger, client, agent, ch.Block, offerHash)
if err != nil {
return err
}
if blocks > 0 {
logger.Add("blocksTillChallangeEnd", blocks).Warn("in challange period")
return ErrChallengePeriodIsNotOver
}
tx, err := w.settle(ctx, logger, acc, agent, ch.Block, offerHash)
if err != nil {
return err
}
if err := w.saveEthTX(logger, job, tx, "Settle",
data.JobChannel, ch.ID, acc.EthAddr,
data.HexFromBytes(w.pscAddr.Bytes())); err != nil {
return err
}
ch.ChannelStatus = data.ChannelWaitUncoop
return w.saveRecord(logger, w.db.Querier, ch)
} | |
c173509 | if err := w.unmarshalDataTo(logger, job.Data, &jdata); err != nil {
return err
}
if err := w.checkDeposit(logger, acc, offer, jdata.Deposit); err != nil {
return err
}
return w.clientPreChannelTopUpSaveTx(logger, job, ch, acc, offer,
jdata.GasPrice, uint64(jdata.Deposit))
} | |
c173510 | w.afterChannelTopUp(job, data.JobClientAfterChannelTopUp)
} | |
c173511 | return err
}
acc, err := w.account(logger, ch.Client)
if err != nil {
return err
}
if err := w.clientValidateChannelForClose(ch); err != nil {
return err
}
return w.doClientPreUncooperativeCloseRequestAndSaveTx(logger, job, ch,
acc, offer, jdata.GasPrice)
} | |
c173512 |
ch.ChannelStatus = data.ChannelInChallenge
if err = w.db.Update(ch); err != nil {
logger.Error(err.Error())
return ErrInternal
}
challengePeriod, err := data.ReadUintSetting(w.db.Querier,
data.SettingsPeriodChallange)
if err != nil {
return err
}
return w.addJobWithDelay(logger, nil,
data.JobClientPreUncooperativeClose, data.JobChannel,
ch.ID, time.Duration(challengePeriod)*eth.BlockDuration)
} | |
c173513 |
}
return w.clientRetrieveAndSaveOffering(logger, job,
ethLog.Block, logOfferingCreated.somcType,
logOfferingCreated.somcData, logOfferingCreated.agentAddr,
logOfferingCreated.offeringHash, logOfferingCreated.currentSupply)
} | |
c173514 | = w.db.FindOneTo(&offering, "hash", hash)
if err == sql.ErrNoRows {
// New offering.
return w.clientRetrieveAndSaveOffering(logger, job,
ethLog.Block, logOfferingPopUp.somcType,
logOfferingPopUp.somcData, logOfferingPopUp.agentAddr,
logOfferingPopUp.offeringHash, logOfferingPopUp.currentSupply)
}
if err != nil {
logger.Error(err.Error())
return ErrInternal
}
// Existing offering, just update offering status.
offering.BlockNumberUpdated = ethLog.Block
offering.Status = data.OfferPoppedUp
return w.saveRecord(logger, w.db.Querier, &offering)
} | |
c173515 | job, data.JobClientAfterOfferingDelete, data.OfferRemoved)
} | |
c173516 |
err = data.Save(w.db.Querier, offering)
if err != nil {
logger.Error(err.Error())
return ErrInternal
}
return nil
} | |
c173517 | := h.selectAllFrom(
logger, data.EndpointTable, tail, args...)
if err != nil {
return nil, err
}
endpoints := make([]data.Endpoint, len(result))
for i, item := range result {
endpoints[i] = *item.(*data.Endpoint)
}
return endpoints, nil
} | |
c173518 |
return nil, ErrInternal
}
ret := make(map[string]interface{})
err = json.Unmarshal([]byte(retStr), &ret)
if err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
return ret, nil
} | |
c173519 | value = $1
WHERE key=$2`, string(d), data.SettingGUI)
if err != nil {
logger.Error(fmt.Sprintf("failed to set gui settings: %v", err))
return ErrInternal
}
return nil
} | |
c173520 | r *http.Request) {
handler(w, r, &Context{})
})
} | |
c173521 | ctx *Context) {
for _, v := range methods {
if v == r.Method {
handler(w, r, ctx)
return
}
}
l.Add("sender", r.RemoteAddr).Warn("not allowed HTTP method")
s.RespondError(logger, w, ErrMethodNotAllowed)
}
} | |
c173522 | pass) {
l.Add("sender", r.RemoteAddr).Warn("access denied")
s.RespondError(logger, w, ErrAccessDenied)
return
}
ctx.Username = name
handler(w, r, ctx)
}
} | |
c173523 | time.Duration(timeout) * time.Millisecond,
logger: logger.Add("type", "messages/ept.Service"),
}, nil
} | |
c173524 |
return result.msg, result.err
case <-time.After(s.timeout):
close(done)
return nil, ErrTimeOut
}
} | |
c173525 | jobTypes := []string{
data.JobClientPreServiceSuspend,
data.JobClientPreServiceUnsuspend,
data.JobClientPreServiceTerminate,
}
// TODO: testing. fix it later.
sid := string(sub.ID)
if err = h.queue.Subscribe(jobTypes, sid, cb); err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
go func() {
for err, ok := <-sub.Err(); ok; {
if err != nil {
logger.Warn(err.Error())
}
}
err := h.queue.Unsubscribe(jobTypes, sid)
if err != nil {
logger.Error(err.Error())
}
}()
return sub, nil
} | |
c173526 | return "", err
}
return hex.EncodeToString(b), nil
} | |
c173527 | "0x") || strings.HasPrefix(s2, "0X") {
s2 = s2[2:]
}
return hex.DecodeString(s2)
} | |
c173528 | return base64.URLEncoding.DecodeString(strings.TrimSpace(string(s)))
} | |
c173529 | to parse ethereum hash: %s", err)
}
return common.BytesToHash(hashBytes), err
} | |
c173530 | = fmt.Errorf("unable to parse ethereum hash: %s", err)
}
return common.BytesToHash(hashBytes), err
} | |
c173531 | = fmt.Errorf("unable to parse ethereum addr: %s", err)
}
return common.BytesToAddress(addrBytes), err
} | |
c173532 | }
return binary.BigEndian.Uint32(b), nil
} | |
c173533 | binary.BigEndian.PutUint32(xBytes[:], x)
return xBytes
} | |
c173534 | binary.BigEndian.PutUint64(xBytes[:], x)
return xBytes
} | |
c173535 | xBytes {
ret[24-len(xBytes)+i] = v
}
return ret
} | |
c173536 |
if err != nil {
return "", err
}
return FromBytes(passwordHash), nil
} | |
c173537 | != nil {
return err
}
return bcrypt.CompareHashAndPassword(hashB, salted)
} | |
c173538 | return 0, fmt.Errorf("key %s is not exist"+
" in Setting table", key)
}
return 0, err
}
value, err := strconv.ParseUint(setting.Value, 10, 64)
if err != nil {
return 0, fmt.Errorf("failed to parse %s setting: %v",
key, err)
}
return value, nil
} | |
c173539 | nil {
return nil, err
}
hash, err := base64.URLEncoding.DecodeString(
strings.TrimSpace(string(offeringHash)))
if err != nil {
return nil, err
}
blockBytes := Uint32ToBytes(block)
return crypto.Keccak256(clientAddr.Bytes(),
agentAddr.Bytes(), blockBytes[:],
common.BytesToHash(hash).Bytes()), nil
} | |
c173540 | return offering.MinUnits*offering.UnitPrice + offering.SetupPrice
} | |
c173541 |
offer, err := h.findActiveOfferingByID(logger, offering)
if err != nil {
return nil, err
}
minDeposit := data.MinDeposit(offer)
if deposit == 0 {
deposit = minDeposit
} else if deposit < minDeposit {
logger.Error(ErrDepositTooSmall.Error())
return nil, ErrDepositTooSmall
}
if err := h.pingOffering(logger, offer); err != nil {
return nil, err
}
rid := util.NewUUID()
jobData := &worker.ClientPreChannelCreateData{Account: acc.ID,
Offering: offering, GasPrice: gasPrice, Deposit: deposit}
if err := job.AddWithData(h.queue, nil, data.JobClientPreChannelCreate,
data.JobChannel, rid, data.JobUser, jobData); err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
return &rid, nil
} | |
c173542 | !ok {
logger.Warn(ErrBadOfferingStatusAction.Error())
return ErrBadOfferingStatusAction
}
offer := &data.Offering{}
err := h.findByPrimaryKey(logger, ErrOfferingNotFound, offer, offering)
if err != nil {
return err
}
jobData := &data.JobPublishData{GasPrice: gasPrice}
if err := job.AddWithData(h.queue, nil, jobType, data.JobOffering,
offering, data.JobUser, jobData); err != nil {
logger.Error(err.Error())
return ErrInternal
}
return nil
} | |
c173543 |
logger, data.OfferingTable.Name(), cond, args)
if err != nil {
return nil, err
}
offsetLimit := h.offsetLimit(offset, limit)
tail := fmt.Sprintf("%s %s %s",
cond, activeOfferingSorting, offsetLimit)
result, err := h.selectAllFrom(
logger, data.OfferingTable, tail, args...)
if err != nil {
return nil, err
}
offerings := make([]data.Offering, len(result))
for k, v := range result {
offerings[k] = *v.(*data.Offering)
}
return &GetClientOfferingsResult{offerings, count}, nil
} | |
c173544 | BY block_number_updated DESC`
tail := fmt.Sprintf("%s %s %s", conditions, sorting, offsetLimit)
result, err := h.selectAllFrom(
logger, data.OfferingTable, tail, args...)
if err != nil {
return nil, err
}
offerings := make([]data.Offering, len(result))
for k, v := range result {
offerings[k] = *v.(*data.Offering)
}
return &GetAgentOfferingsResult{offerings, count}, nil
} | |
c173545 | messages.PackWithSignature(msgBytes, agentKey)
if err != nil {
return handleErr(err)
}
offering.RawMsg = data.FromBytes(packed)
hashBytes := common.BytesToHash(crypto.Keccak256(packed))
offering.Hash = data.HexFromBytes(hashBytes.Bytes())
return nil
} | |
c173546 | data.OfferEmpty
offering.Agent = agent.EthAddr
offering.BlockNumberUpdated = 1
offering.CurrentSupply = offering.Supply
// TODO: remove once prepaid is implemented.
offering.BillingType = data.BillingPostpaid
return h.setOfferingHash(logger, offering, template, agent)
} | |
c173547 | offering.ID)
if err != nil {
return err
}
err = update(logger, h.db.Querier, offering)
if err != nil {
return err
}
return nil
} | |
c173548 |
if err != nil {
return nil, err
}
err = insert(logger, h.db.Querier, offering)
if err != nil {
return nil, err
}
return &offering.ID, nil
} | |
c173549 | denied")
return nil, ErrAccessDenied
}
countries, err := h.offeringCountries(logger)
if err != nil {
return nil, err
}
min, max, err := h.offeringsMinMaxPrice(logger)
if err != nil {
return nil, err
}
return &GetClientOfferingsFilterParamsResult{countries, min, max}, nil
} | |
c173550 | err := h.pingOffering(logger, offering)
if err == nil {
ret[offering.ID] = true
offering.SOMCSuccessPing = &now
err = update(logger, h.db.Querier, offering)
if err != nil {
logger.Warn(err.Error())
}
} else {
ret[offering.ID] = false
logger.Debug(err.Error())
}
wg.Done()
}(offering)
}
wg.Wait()
return ret, nil
} | |
c173551 | srv: http.Server{
Addr: conf.Addr,
Handler: http.NewServeMux(),
},
}
return s
} | |
c173552 | {
return s.srv.Handler.(*http.ServeMux)
} | |
c173553 | := log.NewLoggerBase(conf.BaseConfig, l.log)
if err != nil {
return nil, err
}
l.LoggerBase = base
return l, nil
} | |
c173554 | l.logger.Debug(fmt.Sprintf(format, v...))
}
} | |
c173555 | proto += "s"
}
return proto + "://" + conf.Addr + path
} | |
c173556 | return NewHTTPRequestWithURL(method, GetURL(conf, path), req)
} | |
c173557 | := json.Marshal(req)
if err != nil {
return nil, err
}
return http.NewRequest(
method, url, bytes.NewReader(data))
} | |
c173558 | err = json.NewDecoder(resp.Body).Decode(&resp2); err != nil {
return nil, err
}
return &resp2, nil
} | |
c173559 | defer t.mtx.RUnlock()
return s == t.token
} | |
c173560 | if err != nil {
return "", err
}
t.mtx.Lock()
defer t.mtx.Unlock()
t.token = string(data.FromBytes(b))
return t.token, nil
} | |
c173561 |
searchText: searchText,
}
conditions, arguments := h.getLogsConditions(args)
totalItems, err := h.getTotalLogEvents(logger, conditions, arguments)
if err != nil {
return nil, err
}
result, err := h.getLogs(logger, conditions, arguments, offset, limit)
if err != nil {
return nil, err
}
return &GetLogsResult{result, totalItems}, err
} | |
c173562 |
err = data.ValidatePassword(
ch.Password, clientPassword, string(ch.Salt))
if err != nil {
logger.Warn("failed to validate client password: " +
err.Error())
return ErrBadClientPassword
}
return nil
} | |
c173563 |
now := time.Now()
var ipPtr *string
if len(ip) != 0 {
ipPtr = pointer.ToString(ip)
}
var portPtr *uint16
if port != 0 {
portPtr = pointer.ToUint16(port)
}
err = h.db.InTransaction(func(tx *reform.TX) error {
sess := data.Session{
ID: util.NewUUID(),
Channel: ch.ID,
Started: now,
LastUsageTime: now,
ClientIP: ipPtr,
ClientPort: portPtr,
}
if err := tx.Insert(&sess); err != nil {
return err
}
if ch.ServiceStatus == data.ServiceActivating {
err := job.AddWithData(h.queue, tx,
data.JobClientCompleteServiceTransition,
data.JobChannel, ch.ID, data.JobSessionServer,
data.ServiceActive)
if err != nil && err != job.ErrDuplicatedJob {
return err
}
}
return nil
})
if err != nil {
logger.Error(err.Error())
return nil, ErrInternal
}
return &offer, nil
} | |
c173564 | logger.Error(err.Error())
return err
}
}
sess, err := h.findCurrentSession(logger, ch.ID)
if err != nil {
// Client adapter can signal failure immediately, when no
// session is yet created.
if err == ErrSessionNotFound && clientStop {
return nil
}
return err
}
logger = logger.Add("session", sess)
if units != 0 {
// TODO: Use unit size instead of this hardcode.
units /= 1024 * 1024
switch prod.UsageRepType {
case data.ProductUsageIncremental:
sess.UnitsUsed += units
case data.ProductUsageTotal:
sess.UnitsUsed = units
default:
logger.Fatal("unsupported product usage")
}
}
sess.LastUsageTime = time.Now()
if stopSession {
sess.Stopped = pointer.ToTime(sess.LastUsageTime)
}
logger.Info("updating session")
if err := h.db.Save(sess); err != nil {
logger.Error(err.Error())
return ErrInternal
}
return nil
} | |
c173565 | offering.MaxBillingUnitLag,
MaxSuspendTime: offering.MaxSuspendTime,
MaxInactiveTimeSec: offering.MaxInactiveTimeSec,
FreeUnits: offering.FreeUnits,
Nonce: offering.ID,
ServiceSpecificParameters: offering.AdditionalParams,
}
return msg
} | |
c173566 | err != nil || !result.Valid() || len(result.Errors()) != 0 {
return false
}
return true
} | |
c173567 | cfg.ReleaseStage,
NotifyReleaseStages: []string{production, staging},
AppVersion: version,
})
cli := new(Client)
cli.db = db
cli.logger = log
cli.notifier = bugsnag.New(user(cfg.UserID))
//check enable service
e := cli.allowed()
cli.enable = e
enable = e
notifier = cli.notifier
return cli, nil
} | |
c173568 | notifier != nil {
notifier.NotifySync(
errors.New(err, 3), true,
metadata([]data.HexString{defaultAccEth}))
}
panic(err)
}
} | |
c173569 | if err := json.Unmarshal(req.Args, args); err != nil {
logger.Add("arguments", req.Args).Warn(
"failed to parse request arguments: " + err.Error())
s.RespondError(logger, w, ErrFailedToParseRequest)
return false
}
return true
} | |
c173570 | serviceString)
service := parseService(serviceString)
for k := range serverStrings {
// fmt.Println("Server: ", serverStrings[j])
server := parseServer(serverStrings[k])
service.Servers = append(service.Servers, server)
}
i.Services = append(i.Services, service)
}
return nil
} | |
c173571 | version,
M: mode,
ClientID: clientID,
ClientSecret: clientSecret,
AccessToken: accessToken,
})
return &Client{
sling: b,
Venues: newVenueService(b.New()),
}
} | |
c173572 | strconv.Atoi(limit)
r, _ := strconv.Atoi(remain)
return &RateLimit{
Limit: l,
Path: path,
Remaining: r,
}
} | |
c173573 | os.FileMode) error {
return nil
} | |
c173574 | state.m.Lock()
defer state.m.Unlock()
state.c = c
} | |
c173575 | defer t.m.Unlock()
t.cmd = path
} | |
c173576 | to create output directory: %v\n", err)
return err
}
t.m.Lock()
defer t.m.Unlock()
t.outputDir = path
return nil
} | |
c173577 | {
t.m.Lock()
defer t.m.Unlock()
t.p.stdin = stdin
t.p.stderr = stderr
} | |
c173578 | v
options[i] = new_opt
return options
}
}
return append(options, prefix + v)
} | |
c173579 | len(m.Data) < m.offset+len(bs) {
m.Error = io.ErrShortBuffer
return
}
m.offset += copy(m.Data[m.offset:], bs)
} | |
c173580 |
m.Error = io.ErrShortBuffer
return
}
m.MarshalUint32(uint32(len(s)))
m.offset += copy(m.Data[m.offset:], s)
m.offset += copy(m.Data[m.offset:], padBytes[:Padding(len(s))])
} | |
c173581 |
m.Error = io.ErrShortBuffer
return
}
m.MarshalUint32(uint32(len(bs)))
m.offset += copy(m.Data[m.offset:], bs)
m.offset += copy(m.Data[m.offset:], padBytes[:Padding(len(bs))])
} | |
c173582 | else {
m.MarshalUint8(0)
}
} | |
c173583 |
return
}
m.Data[m.offset+0] = byte(v >> 24)
m.Data[m.offset+1] = byte(v >> 16)
m.Data[m.offset+2] = byte(v >> 8)
m.Data[m.offset+3] = byte(v)
m.offset += 4
} | |
c173584 | >> 32)
m.Data[m.offset+4] = byte(v >> 24)
m.Data[m.offset+5] = byte(v >> 16)
m.Data[m.offset+6] = byte(v >> 8)
m.Data[m.offset+7] = byte(v)
m.offset += 8
} | |
c173585 | fmt.Errorf("%s exceeds size limit; %d > %d", field, size, limit)
} | |
c173586 | <= 126 && p[i] != byte('=')) || p[i] == byte('\t')) {
return i
}
}
return i
} | |
c173587 | (d.enc.isText && p[i] == byte('\r')) {
return i
}
}
return i
} | |
c173588 | bytes.NewBuffer(nil),
leftovers: bytes.NewBuffer(nil)}
} | |
c173589 |
// make sure we can resolve the constuctor arguments
for i := 0; i < constructorType.NumIn(); i++ {
inType := constructorType.In(i)
_, ok := di.registry[inType]
if !ok {
return fmt.Errorf("Can't resolve function arguments - can't find a %s for a %s\n", inType, outType)
}
}
di.registry[outType] = constructorFunc
return nil
} | |
c173590 | := di.Register(constructorFunc)
if err != nil {
panic(err)
}
} | |
c173591 |
if di.caching {
return di.cachedCreateFromType(varType).Interface()
} else {
return di.CreateFromType(varType).Interface()
}
} | |
c173592 |
di.instances[atype] = di.createFromType(atype)
}
return di.instances[atype]
} | |
c173593 | make(map[reflect.Type]interface{}),
instances: make(map[reflect.Type]reflect.Value),
}
} | |
c173594 | instances: make(map[reflect.Type]reflect.Value),
caching: true,
}
} | |
c173595 | {
url, err = s.AssetPipeline.AssetUrl(name)
if err == nil {
url = s.prefix + url
}
return
} | |
c173596 |
return &prefixPipeline{
prefix: prefix,
AssetPipeline: p,
}
} | |
c173597 | {
handler.getResponse(r).Send(w)
} | |
c173598 | expected %d", handler.methodName, actual, expected))
}
out := method.Call(args)
if out[0].IsNil() {
panic("Response from controller was nil")
}
resp := out[0].Interface().(Response)
if resp == nil {
panic("Response from controller was not Response interface")
}
controller.Session().WriteToResponse(resp)
return resp
} | |
c173599 | r *Response
responseType := reflect.TypeOf(r).Elem()
return (method.Kind() == reflect.Func) &&
(typeOfMethod.NumMethod() == 0) &&
(typeOfMethod.NumOut() == 1) &&
typeOfMethod.Out(0) == responseType
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.