// DeleteLiveRecordVodConfig 删除直播录制转点播配置。
//
// https://help.aliyun.com/document_detail/63969.html?spm=a2c4g.11186623.6.669.mKTDcM
353996
func (l *Live) DeleteLiveRecordVodConfig(streamName string, resp interface{}) (err error) {
	req := l.cloneRequest(DeleteLiveRecordVodConfigAction)
	req.SetArgs("StreamName", streamName)
	err = l.rpc.Query(req, resp)
	return
}
457699
func (l *Live) DescribeLiveAppRecordConfig(resp interface{}) (err error) {
	req := l.cloneRequest(DescribeLiveAppRecordConfigAction)
	err = l.rpc.Query(req, resp)
	return
}
1372740
func ConntrackDeleteFilter(table ConntrackTableType, family InetFamily, filter CustomConntrackFilter) (uint, error) {
	return pkgHandle.ConntrackDeleteFilter(table, family, filter)
}
1372573
func (client *Client) DeleteLIFF(liffID string) *DeleteLIFFCall {
	return &DeleteLIFFCall{
		c:      client,
		liffID: liffID,
	}
}
377791
func (l *Live) AddLiveAppRecordConfig(ossInfo OssInfo, resp interface{}) (err error) {
	req := l.cloneRequest(AddLiveAppRecordConfigAction)
	if global.EmptyString == req.AppName || ossInfo.OssEndpoint == global.EmptyString || ossInfo.OssBucket == global.EmptyString || ossInfo.OssObjectPrefix == global.EmptyString {
		return errors.New(" appName|ossEndpoint|ossBucket|ossObjectPrefix should not to be empty")
	}
	req.SetArgs("OssEndpoint", ossInfo.OssEndpoint)
	req.SetArgs("OssBucket", ossInfo.OssBucket)
	req.SetArgs("OssObjectPrefix", ossInfo.OssObjectPrefix)
	err = l.rpc.Query(req, resp)
	return
}
670186
func (s *CSVInput) SetRecordDelimiter(v string) *CSVInput {
	s.RecordDelimiter = &v
	return s
}
529780
func (s *remoteSite) deleteConnectionRecord() {
	s.localAccessPoint.DeleteTunnelConnection(s.connInfo.GetClusterName(), s.connInfo.GetName())
}
1034673
func (client *QuobyteClient) DeleteVolumeByResolvingNamesToUUID(volume, tenant string) error {
	volumeUUID, err := client.GetVolumeUUID(volume, tenant)
	if err != nil {
		return err
	}

	return client.DeleteVolume(volumeUUID)
}
636593
func (s *schemaVersionSyncer) RemoveSelfVersionPath() error {
	startTime := time.Now()
	var err error
	defer func() {
		metrics.DeploySyncerHistogram.WithLabelValues(metrics.SyncerClear, metrics.RetLabel(err)).Observe(time.Since(startTime).Seconds())
	}()

	err = DeleteKeyFromEtcd(s.selfSchemaVerPath, s.etcdCli, keyOpDefaultRetryCnt, keyOpDefaultTimeout)
	return errors.Trace(err)
}
731375
func CleanOldDeletedRepos(
	ctx context.Context, config libkbfs.Config,
	tlfHandle *tlfhandle.Handle) (err error) {
	fs, err := libfs.NewFS(
		ctx, config, tlfHandle, data.MasterBranch,
		path.Join(kbfsRepoDir, kbfsDeletedReposDir),
		"" /* uniq ID isn't used for removals */, keybase1.MDPriorityGit)
	switch errors.Cause(err).(type) {
	case idutil.NoSuchNameError:
		// Nothing to clean.
		return nil
	case nil:
	default:
		return err
	}

	deletedRepos, err := fs.ReadDir("/")
	if err != nil {
		return err
	}

	if len(deletedRepos) == 0 {
		return nil
	}

	log := config.MakeLogger("")
	now := config.Clock().Now()

	log.CDebugf(ctx, "Checking %d deleted repos for cleaning in %s",
		len(deletedRepos), tlfHandle.GetCanonicalPath())
	defer func() {
		log.CDebugf(ctx, "Done checking deleted repos: %+v", err)
	}()
	for _, fi := range deletedRepos {
		parts := strings.Split(fi.Name(), "-")
		if len(parts) < 2 {
			log.CDebugf(ctx,
				"Ignoring deleted repo name with wrong format: %s", fi.Name())
			continue
		}

		deletedTimeUnixNano, err := strconv.ParseInt(
			parts[len(parts)-1], 10, 64)
		if err != nil {
			log.CDebugf(ctx,
				"Ignoring deleted repo name with wrong format: %s: %+v",
				fi.Name(), err)
			continue
		}

		deletedTime := time.Unix(0, deletedTimeUnixNano)
		if deletedTime.Add(minDeletedAgeForCleaning).After(now) {
			// Repo was deleted too recently.
			continue
		}

		log.CDebugf(ctx, "Cleaning deleted repo %s", fi.Name())
		err = libfs.RecursiveDelete(ctx, fs, fi)
		if err != nil {
			return err
		}
	}
	return nil
}
747412
func (u *FakeAPIUtil) DeletePV(pvName string) error {
	if u.shouldFail {
		return fmt.Errorf("API failed")
	}

	pv, exists := u.cache.GetPV(pvName)
	if exists {
		u.deletedPVs[pvName] = pv
		delete(u.createdPVs, pvName)
		u.cache.DeletePV(pvName)
		return nil
	}
	return errors.NewNotFound(v1.Resource("persistentvolumes"), pvName)
}
502792
func deleteRecord(c *godo.Client, zoneName string, recordID int) error {
	_, err := c.Domains.DeleteRecord(context.TODO(), zoneName, recordID)
	if err != nil {
		return fmt.Errorf("error deleting record: %v", err)
	}

	return nil
}
278271
func (client *storageRESTClient) DeleteVol(volume string) (err error) {
	values := make(url.Values)
	values.Set(storageRESTVolume, volume)
	respBody, err := client.call(storageRESTMethodDeleteVol, values, nil, -1)
	defer http.DrainBody(respBody)
	return err
}
531206
func (client *AuroraDNSClient) RemoveRecord(zoneID string, recordID string) (*records.RemoveRecordResponse, error) {
	logrus.Debugf("RemoveRecord(%s, %s)", zoneID, recordID)
	relativeURL := fmt.Sprintf("zones/%s/records/%s", zoneID, recordID)

	_, err := client.requestor.Request(relativeURL, "DELETE", nil)
	if err != nil {
		logrus.Errorf("Failed to remove record: %s", err)

		return nil, err
	}

	return &records.RemoveRecordResponse{}, nil
}
920673
func (manager *configManager) DeleteNodeConf(nodeID string) error {
	if len(nodeID) == 0 {
		return fmt.Errorf("node id cannot be nil")
	}

	manager.Lock()
	defer manager.Unlock()

	// remove dode data from kvdb
	if _, err := manager.kv.Delete(getNodeKeyFromNodeID(nodeID)); err != nil {
		return err
	}

	return nil
}
1203945
func (resizeMap *volumeResizeMap) DeletePVC(pvc *v1.PersistentVolumeClaim) {
	pvcUniqueName := types.UniquePVCName(pvc.UID)
	klog.V(5).Infof("Removing PVC %v from resize map", pvcUniqueName)
	resizeMap.Lock()
	defer resizeMap.Unlock()
	delete(resizeMap.pvcrs, pvcUniqueName)
}
1135023
func (c *Cloud) deleteListenerV2(listener *elbv2.Listener) error {
	_, err := c.elbv2.DeleteListener(&elbv2.DeleteListenerInput{ListenerArn: listener.ListenerArn})
	if err != nil {
		return fmt.Errorf("Error deleting load balancer listener: %q", err)
	}
	_, err = c.elbv2.DeleteTargetGroup(&elbv2.DeleteTargetGroupInput{TargetGroupArn: listener.DefaultActions[0].TargetGroupArn})
	if err != nil {
		return fmt.Errorf("Error deleting load balancer target group: %q", err)
	}
	return nil
}