id
stringlengths 2
7
| text
stringlengths 17
51.2k
| title
stringclasses 1
value |
|---|---|---|
c3200
|
[]*OriginEndpoint) *ListOriginEndpointsOutput {
s.OriginEndpoints = v
return s
}
| |
c3201
|
string) *RotateIngestEndpointCredentialsInput {
s.IngestEndpointId = &v
return s
}
| |
c3202
|
s.MaxVideoBitsPerSecond = &v
return s
}
| |
c3203
|
s.MinVideoBitsPerSecond = &v
return s
}
| |
c3204
|
s.StreamOrder = &v
return s
}
| |
c3205
|
{
return func(d *Downloader) {
d.RequestOptions = append(d.RequestOptions, opts...)
}
}
| |
c3206
|
// Wait for completion
close(ch)
d.wg.Wait()
} else {
// Checking if we read anything new
for d.err == nil {
d.getChunk()
}
// We expect a 416 error letting us know we are done downloading the
// total bytes. Since we do not know the content's length, this will
// keep grabbing chunks of data until the range of bytes specified in
// the request is out of range of the content. Once, this happens, a
// 416 should occur.
e, ok := d.err.(awserr.RequestFailure)
if ok && e.StatusCode() == http.StatusRequestedRangeNotSatisfiable {
d.err = nil
}
}
// Return error
return d.written, d.err
}
| |
c3207
|
// of download producer.
continue
}
if err := d.downloadChunk(chunk); err != nil {
d.setErr(err)
}
}
}
| |
c3208
|
if err := d.downloadChunk(chunk); err != nil {
d.setErr(err)
}
}
| |
c3209
|
nil {
d.setErr(err)
}
// Update the position based on the amount of data received.
d.pos = d.written
}
| |
c3210
|
resp.Body.Close()
if err == nil {
break
}
chunk.cur = 0
logMessage(d.cfg.S3, aws.LogDebugWithRequestRetries,
fmt.Sprintf("DEBUG: object part body download interrupted %s, err, %v, retrying attempt %d",
aws.StringValue(in.Key), err, retry))
}
d.incrWritten(n)
return err
}
| |
c3211
|
defer d.m.Unlock()
return d.totalBytes
}
| |
c3212
|
a numbered total exists
// If one does not exist, we will assume the total to be -1, undefined,
// and sequentially download each chunk until hitting a 416 error
totalStr := parts[len(parts)-1]
if totalStr != "*" {
total, err = strconv.ParseInt(totalStr, 10, 64)
if err != nil {
d.err = err
return
}
}
d.totalBytes = total
}
}
| |
c3213
|
defer d.m.Unlock()
return d.err
}
| |
c3214
|
defer d.m.Unlock()
d.err = e
}
| |
c3215
|
return fmt.Sprintf("bytes=%d-%d", c.start, c.start+c.size-1)
}
| |
c3216
|
s.BrokerAZDistribution = &v
return s
}
| |
c3217
|
{
s.ClientSubnets = v
return s
}
| |
c3218
|
*StorageInfo) *BrokerNodeGroupInfo {
s.StorageInfo = v
return s
}
| |
c3219
|
s.ClientSubnet = &v
return s
}
| |
c3220
|
s.ConfigurationArn = &v
return s
}
| |
c3221
|
s.ZookeeperConnectString = &v
return s
}
| |
c3222
|
*ClusterInfo) *DescribeClusterOutput {
s.ClusterInfo = v
return s
}
| |
c3223
|
s.DataVolumeKMSKeyId = &v
return s
}
| |
c3224
|
{
s.BootstrapBrokerString = &v
return s
}
| |
c3225
|
s.ClusterNameFilter = &v
return s
}
| |
c3226
|
{
s.ClusterInfoList = v
return s
}
| |
c3227
|
{
s.NodeInfoList = v
return s
}
| |
c3228
|
s.AddedToClusterTime = &v
return s
}
| |
c3229
|
*NodeInfo {
s.BrokerNodeInfo = v
return s
}
| |
c3230
|
s.NodeARN = &v
return s
}
| |
c3231
|
*NodeInfo {
s.ZookeeperNodeInfo = v
return s
}
| |
c3232
|
*StorageInfo {
s.EbsStorageInfo = v
return s
}
| |
c3233
|
float64) *ZookeeperNodeInfo {
s.ZookeeperId = &v
return s
}
| |
c3234
|
s.ZookeeperVersion = &v
return s
}
| |
c3235
|
s.DeliveryTime = &v
return s
}
| |
c3236
|
*BusinessReport) *BusinessReportSchedule {
s.LastBusinessReport = v
return s
}
| |
c3237
|
s.CategoryName = &v
return s
}
| |
c3238
|
s.DefaultConferenceProviderArn = &v
return s
}
| |
c3239
|
s.AudioList = v
return s
}
| |
c3240
|
s.SsmlList = v
return s
}
| |
c3241
|
string) *CreateConferenceProviderInput {
s.ConferenceProviderName = &v
return s
}
| |
c3242
|
s.DeveloperName = &v
return s
}
| |
c3243
|
s.PrivacyPolicy = &v
return s
}
| |
c3244
|
s.ConnectionStatus = &v
return s
}
| |
c3245
|
*DeviceStatusInfo {
s.DeviceStatusDetails = v
return s
}
| |
c3246
|
*AddressBook) *GetAddressBookOutput {
s.AddressBook = v
return s
}
| |
c3247
|
*GetConferencePreferenceOutput {
s.Preference = v
return s
}
| |
c3248
|
*ConferenceProvider) *GetConferenceProviderOutput {
s.ConferenceProvider = v
return s
}
| |
c3249
|
{
s.Contact = v
return s
}
| |
c3250
|
*GatewayGroup) *GetGatewayGroupOutput {
s.GatewayGroup = v
return s
}
| |
c3251
|
{
s.Gateway = v
return s
}
| |
c3252
|
{
s.Room = v
return s
}
| |
c3253
|
*SkillGroup) *GetSkillGroupOutput {
s.SkillGroup = v
return s
}
| |
c3254
|
s.CommsProtocol = &v
return s
}
| |
c3255
|
[]*BusinessReportSchedule) *ListBusinessReportSchedulesOutput {
s.BusinessReportSchedules = v
return s
}
| |
c3256
|
[]*ConferenceProvider) *ListConferenceProvidersOutput {
s.ConferenceProviders = v
return s
}
| |
c3257
|
[]*DeviceEvent) *ListDeviceEventsOutput {
s.DeviceEvents = v
return s
}
| |
c3258
|
*ListGatewayGroupsOutput {
s.GatewayGroups = v
return s
}
| |
c3259
|
{
s.SkillSummaries = v
return s
}
| |
c3260
|
[]*Category) *ListSkillsStoreCategoriesOutput {
s.CategoryList = v
return s
}
| |
c3261
|
[]*SkillsStoreSkill) *ListSkillsStoreSkillsByCategoryOutput {
s.SkillsStoreSkills = v
return s
}
| |
c3262
|
[]*SmartHomeAppliance) *ListSmartHomeAppliancesOutput {
s.SmartHomeAppliances = v
return s
}
| |
c3263
|
s.RequirePin = &v
return s
}
| |
c3264
|
s.OneClickIdDelay = &v
return s
}
| |
c3265
|
s.OneClickPinDelay = &v
return s
}
| |
c3266
|
*ConferencePreference) *PutConferencePreferenceInput {
s.ConferencePreference = v
return s
}
| |
c3267
|
map[string]*string) *PutSkillAuthorizationInput {
s.AuthorizationResult = v
return s
}
| |
c3268
|
string) *RegisterAVSDeviceInput {
s.AmazonId = &v
return s
}
| |
c3269
|
*ResolveRoomOutput {
s.RoomSkillParameters = v
return s
}
| |
c3270
|
[]*AddressBookData) *SearchAddressBooksOutput {
s.AddressBooks = v
return s
}
| |
c3271
|
[]*ContactData) *SearchContactsOutput {
s.Contacts = v
return s
}
| |
c3272
|
[]*RoomData) *SearchRoomsOutput {
s.Rooms = v
return s
}
| |
c3273
|
[]*SkillGroupData) *SearchSkillGroupsOutput {
s.SkillGroups = v
return s
}
| |
c3274
|
[]*Filter) *SendAnnouncementInput {
s.RoomFilters = v
return s
}
| |
c3275
|
s.TimeToLiveInSeconds = &v
return s
}
| |
c3276
|
{
s.AnnouncementArn = &v
return s
}
| |
c3277
|
s.BulletPoints = v
return s
}
| |
c3278
|
*SkillDetails {
s.DeveloperInfo = v
return s
}
| |
c3279
|
s.EndUserLicenseAgreement = &v
return s
}
| |
c3280
|
s.GenericKeywords = v
return s
}
| |
c3281
|
s.InvocationPhrase = &v
return s
}
| |
c3282
|
s.NewInThisVersionBulletPoints = v
return s
}
| |
c3283
|
*SkillDetails {
s.Reviews = v
return s
}
| |
c3284
|
s.SkillTypes = v
return s
}
| |
c3285
|
{
s.SkillDetails = v
return s
}
| |
c3286
|
s.ManufacturerName = &v
return s
}
| |
c3287
|
return nil, errors.New("this controller does not support --destroy-storage")
}
argsV4 := params.Entities{
Entities: make([]params.Entity, len(argsV5.Applications)),
}
for i, arg := range argsV5.Applications {
argsV4.Entities[i].Tag = arg.ApplicationTag
}
args = argsV4
}
var result params.DestroyApplicationResults
if err := c.facade.FacadeCall("DestroyApplication", args, &result); err != nil {
return nil, errors.Trace(err)
}
if n := len(result.Results); n != len(argsV5.Applications) {
return nil, errors.Errorf("expected %d result(s), got %d", len(argsV5.Applications), n)
}
for i, result := range result.Results {
allResults[index[i]] = result
}
return allResults, nil
}
| |
c3288
|
names.NewApplicationTag(in.ApplicationName).String(),
Scale: in.Scale,
ScaleChange: in.ScaleChange,
Force: in.Force,
}},
}
var results params.ScaleApplicationResults
if err := c.facade.FacadeCall("ScaleApplications", args, &results); err != nil {
return params.ScaleApplicationResult{}, errors.Trace(err)
}
if n := len(results.Results); n != 1 {
return params.ScaleApplicationResult{}, errors.Errorf("expected 1 result, got %d", n)
}
result := results.Results[0]
if err := result.Error; err != nil {
return params.ScaleApplicationResult{}, err
}
return results.Results[0], nil
}
| |
c3289
|
applications {
args.Entities = append(args.Entities,
params.Entity{Tag: names.NewApplicationTag(application).String()})
}
err := c.facade.FacadeCall("GetConstraints", args, &results)
if err != nil {
return nil, errors.Trace(err)
}
for i, result := range results.Results {
if result.Error != nil {
return nil, errors.Annotatef(result.Error, "unable to get constraints for %q", applications[i])
}
allConstraints = append(allConstraints, result.Constraints)
}
return allConstraints, nil
}
| |
c3290
|
constraints,
}
return c.facade.FacadeCall("SetConstraints", args, nil)
}
| |
c3291
|
BranchName: branchName,
}
err := c.facade.FacadeCall("Get", args, &results)
return &results, err
}
| |
c3292
|
ApplicationName: application,
Options: options,
}
return c.facade.FacadeCall("Set", p, nil)
}
| |
c3293
|
options,
}
return c.facade.FacadeCall("Unset", p, nil)
}
| |
c3294
|
args := params.ApplicationCharmRelations{ApplicationName: application}
err := c.facade.FacadeCall("CharmRelations", args, &results)
return results.CharmRelations, err
}
| |
c3295
|
params.DestroyRelation{
Endpoints: endpoints,
Force: force,
MaxWait: maxWait,
}
return c.facade.FacadeCall("DestroyRelation", args, nil)
}
| |
c3296
|
RelationId: relationId,
Force: force,
MaxWait: maxWait,
}
return c.facade.FacadeCall("DestroyRelation", args, nil)
}
| |
c3297
|
return errors.Trace(err)
}
if len(results.Results) != len(args.Args) {
return errors.Errorf("expected %d results, got %d", len(args.Args), len(results.Results))
}
return results.Combine()
}
| |
c3298
|
Alias: arg.ControllerInfo.Alias,
Addrs: arg.ControllerInfo.Addrs,
CACert: arg.ControllerInfo.CACert,
}
}
err := c.facade.FacadeCall("Consume", args, &consumeRes)
if err != nil {
return "", errors.Trace(err)
}
if resultLen := len(consumeRes.Results); resultLen != 1 {
return "", errors.Errorf("expected 1 result, got %d", resultLen)
}
if err := consumeRes.Results[0].Error; err != nil {
return "", errors.Trace(err)
}
localName := arg.Offer.OfferName
if arg.ApplicationAlias != "" {
localName = arg.ApplicationAlias
}
return localName, nil
}
| |
c3299
|
}},
}
var results params.ErrorResults
err := c.facade.FacadeCall("SetApplicationsConfig", args, &results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.