TypeScript api.client.telegrafConfigs类代码示例

) => async (dispatch): Promise<void> => {
  try {
    await client.telegrafConfigs.removeLabels(telegrafID, labels)
    const telegraf = await client.telegrafConfigs.get(telegrafID)

    dispatch(editTelegraf(telegraf))
  } catch (error) {
    console.error(error)
    dispatch(notify(removeTelelgrafLabelFailed()))
  }
}

export const createOrUpdateTelegrafConfigAsync = () => async (
  dispatch,
  getState: GetState
) => {
  const {
    dataLoading: {
      dataLoaders: {
        telegrafPlugins,
        telegrafConfigID,
        telegrafConfigName,
        telegrafConfigDescription,
      },
      steps: {bucket},
    },
    orgs: {
      org: {name},
    },
  } = getState()

  const influxDB2Out = {
    name: TelegrafPluginOutputInfluxDBV2.NameEnum.InfluxdbV2,
    type: TelegrafPluginOutputInfluxDBV2.TypeEnum.Output,
    config: {
      urls: [`${window.location.origin}`],
      token: '$INFLUX_TOKEN',
      organization: name,
      bucket,
    },
  }

  const plugins = telegrafPlugins.reduce(
    (acc, tp) => {
      if (tp.configured === ConfigurationState.Configured) {
        return [...acc, tp.plugin || createNewPlugin(tp.name)]
      }

      return acc
    },
    [influxDB2Out]
  )

  if (telegrafConfigID) {
    const telegraf = await client.telegrafConfigs.update(telegrafConfigID, {
      name: telegrafConfigName,
      description: telegrafConfigDescription,
      plugins,
    })
    dispatch(editTelegraf(telegraf))
    dispatch(setTelegrafConfigID(telegrafConfigID))
    return
  }

  createTelegraf(dispatch, getState, plugins)
}

const createTelegraf = async (dispatch, getState, plugins) => {
  try {
    const {
      dataLoading: {
        dataLoaders: {telegrafConfigName, telegrafConfigDescription},
        steps: {bucket, orgID, bucketID},
      },
    } = getState()

    const telegrafRequest: TelegrafRequest = {
      name: telegrafConfigName,
      description: telegrafConfigDescription,
      agent: {collectionInterval: DEFAULT_COLLECTION_INTERVAL},
      organizationID: orgID,
      plugins,
    }

    // create telegraf config
    const tc = await client.telegrafConfigs.create(telegrafRequest)

    const permissions = [
      {
        action: Permission.ActionEnum.Write,
        resource: {
          type: PermissionResource.TypeEnum.Buckets,
          id: bucketID,
          orgID,
        },
      },
      {
        action: Permission.ActionEnum.Read,
        resource: {
          type: PermissionResource.TypeEnum.Telegrafs,
          id: tc.id,
          orgID,
        },
      },
    ]

    const token = {
      name: `${telegrafConfigName} token`,
      orgID,
      description: `WRITE ${bucket} bucket / READ ${telegrafConfigName} telegraf config`,
      permissions,
    }

    // create token
    const createdToken = await createAuthorization(token)

    // add token to data loader state
    dispatch(setToken(createdToken.token))

    // add token to authorizations state
    dispatch(addAuthorization(createdToken))

    // create token label
    const properties = {
      color: '#FFFFFF',
      description: `token for telegraf config: ${telegrafConfigName}`,
      tokenID: createdToken.id,
    } as ILabelProperties // hack to make compiler work

    const createdLabel = await client.labels.create({
      orgID,
      name: '@influxdata.token',
      properties,
    })

    // add label to telegraf config
    const label = await client.telegrafConfigs.addLabel(tc.id, createdLabel)

    const config = {
      ...tc,
      labels: [label],
    }

    dispatch(setTelegrafConfigID(tc.id))
    dispatch(addTelegraf(config))
    dispatch(notify(TelegrafConfigCreationSuccess))
  } catch (error) {
    dispatch(notify(TelegrafConfigCreationError))
  }
}