Struct qiniu_upload_token::UploadPolicyBuilder

pub struct UploadPolicyBuilder { /* private fields */ }

上传策略构建器

用于生成上传策略，一旦生成完毕，上传策略将无法被修改

Implementations

impl UploadPolicyBuilder

pub fn new_policy_for_bucket(
    bucket: impl Into<BucketName>,
    upload_token_lifetime: Duration
) -> Self

为指定的存储空间生成的上传策略

允许用户上传文件到指定的存储空间，不限制上传客户端指定对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

Examples found in repository

src/upload_policy.rs (line 67)

    pub fn new_for_bucket(bucket: impl Into<BucketName>, upload_token_lifetime: Duration) -> UploadPolicyBuilder {
        UploadPolicyBuilder::new_policy_for_bucket(bucket, upload_token_lifetime)
    }

src/upload_token.rs (line 450)

    fn make_policy(&self) -> AnyResult<UploadPolicy> {
        let mut builder =
            UploadPolicyBuilder::new_policy_for_bucket(self.bucket.to_string(), self.upload_token_lifetime);
        if let Some(on_policy_generated) = self.on_policy_generated.as_ref() {
            on_policy_generated(&mut builder)?;
        }
        Ok(builder.build())
    }

pub fn new_policy_for_object(
    bucket: impl Into<BucketName>,
    object: impl Into<ObjectName>,
    upload_token_lifetime: Duration
) -> Self

为指定的存储空间和对象名称生成的上传策略

允许用户以指定的对象名称上传文件到指定的存储空间。 上传客户端不能指定与上传策略冲突的对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

Examples found in repository

src/upload_policy.rs (line 82)

    pub fn new_for_object(
        bucket: impl Into<BucketName>,
        object: impl Into<ObjectName>,
        upload_token_lifetime: Duration,
    ) -> UploadPolicyBuilder {
        UploadPolicyBuilder::new_policy_for_object(bucket, object, upload_token_lifetime)
    }

src/upload_token.rs (lines 572-576)

    fn make_policy(&self) -> AnyResult<UploadPolicy> {
        let mut builder = UploadPolicyBuilder::new_policy_for_object(
            self.bucket.to_string(),
            self.object.to_string(),
            self.upload_token_lifetime,
        );
        if let Some(on_policy_generated) = self.on_policy_generated.as_ref() {
            on_policy_generated(&mut builder)?;
        }
        Ok(builder.build())
    }

pub fn new_policy_for_objects_with_prefix(
    bucket: impl Into<BucketName>,
    prefix: impl AsRef<str>,
    upload_token_lifetime: Duration
) -> Self

为指定的存储空间和对象名称前缀生成的上传策略

允许用户以指定的对象名称前缀上传文件到指定的存储空间。 上传客户端指定包含该前缀的对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

Examples found in repository

src/upload_policy.rs (line 97)

    pub fn new_for_objects_with_prefix(
        bucket: impl Into<BucketName>,
        prefix: impl AsRef<str>,
        upload_token_lifetime: Duration,
    ) -> UploadPolicyBuilder {
        UploadPolicyBuilder::new_policy_for_objects_with_prefix(bucket, prefix, upload_token_lifetime)
    }

pub fn token_lifetime(&mut self, lifetime: Duration) -> &mut Self

指定上传凭证有效期

Examples found in repository

src/upload_policy.rs (line 314)

    pub fn new_policy_for_bucket(bucket: impl Into<BucketName>, upload_token_lifetime: Duration) -> Self {
        let mut policy = Self {
            inner: json!({
                SCOPE_KEY: bucket.into().to_string(),
            }),
        };
        policy.token_lifetime(upload_token_lifetime);
        policy
    }

    /// 为指定的存储空间和对象名称生成的上传策略
    ///
    /// 允许用户以指定的对象名称上传文件到指定的存储空间。
    /// 上传客户端不能指定与上传策略冲突的对象名称。
    ///
    /// 上传策略根据给出的客户端配置指定上传凭证有效期
    pub fn new_policy_for_object(
        bucket: impl Into<BucketName>,
        object: impl Into<ObjectName>,
        upload_token_lifetime: Duration,
    ) -> Self {
        let mut policy = Self {
            inner: json!({
                SCOPE_KEY: bucket.into().to_string() + ":" + object.into().as_str(),
            }),
        };
        policy.token_lifetime(upload_token_lifetime);
        policy
    }

    /// 为指定的存储空间和对象名称前缀生成的上传策略
    ///
    /// 允许用户以指定的对象名称前缀上传文件到指定的存储空间。
    /// 上传客户端指定包含该前缀的对象名称。
    ///
    /// 上传策略根据给出的客户端配置指定上传凭证有效期
    pub fn new_policy_for_objects_with_prefix(
        bucket: impl Into<BucketName>,
        prefix: impl AsRef<str>,
        upload_token_lifetime: Duration,
    ) -> Self {
        let mut policy = Self {
            inner: json!({
                SCOPE_KEY: bucket.into().to_string() + ":" + prefix.as_ref(),
                IS_PREFIXAL_SCOPE_KEY: 1,
            }),
        };
        policy.token_lifetime(upload_token_lifetime);
        policy
    }

pub fn token_deadline(&mut self, deadline: SystemTime) -> &mut Self

指定上传凭证过期时间

pub fn insert_only(&mut self) -> &mut Self

仅允许创建新的对象，不允许覆盖和修改同名对象

pub fn enable_mime_detection(&mut self) -> &mut Self

启用 MIME 类型自动检测

pub fn disable_mime_detection(&mut self) -> &mut Self

禁用 MIME 类型自动检测

pub fn file_type(&mut self, file_type: FileType) -> &mut Self

设置文件类型

pub fn return_url(&mut self, url: impl Into<String>) -> &mut Self

Web 端文件上传成功后，浏览器执行 303 跳转的 URL

通常用于表单上传。 文件上传成功后会跳转到 <return_url>?upload_ret=<queryString>， <queryString> 包含 return_body() 内容。 如不设置 return_url，则直接将 return_body() 的内容返回给客户端

pub fn return_body(&mut self, body: impl Into<String>) -> &mut Self

上传成功后，自定义七牛云最终返回给上传端（在指定 return_url() 时是携带在跳转路径参数中）的数据

支持魔法变量和自定义变量。 return_body 要求是合法的 JSON 文本。 例如 {"key": $(key), "hash": $(etag), "w": $(imageInfo.width), "h": $(imageInfo.height)}

pub fn callback<V: AsRef<[S]>, S: AsRef<str>>(
    &mut self,
    urls: V,
    host: impl Into<String>,
    body: impl Into<String>,
    body_type: impl Into<String>
) -> &mut Self

上传成功后，七牛云向业务服务器发送 POST 请求的 URL 列表，Host，回调请求的内容以及其 Content-Type

七牛服务器会在上传成功后逐一回调 URL 直到有一个成功为止

如果给出的 host 为空字符串，则使用默认的 Host

body 参数必须不能为空，支持魔法变量和自定义变量 body_type 参数表示 body 参数的 Content-Type，如果为空，则为默认的 application/x-www-form-urlencoded

pub fn save_as(&mut self, save_as: impl Into<String>, force: bool) -> &mut Self

自定义对象名称

支持魔法变量和自定义变量。 force 为 false 时，save_as 字段仅当用户上传的时候没有主动指定对象名时起作用， force 为 true 时，将强制按 save_as 字段的内容命名

pub fn file_size_limitation(&mut self, size: impl RangeBounds<u64>) -> &mut Self

限定上传文件尺寸的范围

单位为字节

pub fn mime_types<V: AsRef<[S]>, S: AsRef<str>>(
    &mut self,
    content_types: V
) -> &mut Self

限定用户上传的文件类型

指定本字段值，七牛服务器会侦测文件内容以判断 MIME 类型，再用判断值跟指定值进行匹配， 匹配成功则允许上传，匹配失败则返回 403 状态码

pub fn object_lifetime(&mut self, lifetime: Duration) -> &mut Self

对象生命周期

精确到天

pub fn set(&mut self, k: String, v: JsonValue) -> &mut Self

直接设置上传策略的键值对

Examples found in repository

src/upload_policy.rs (lines 361-371)

    pub fn token_lifetime(&mut self, lifetime: Duration) -> &mut Self {
        self.set(
            DEADLINE_KEY.into(),
            JsonValue::Number(
                SystemTime::now()
                    .checked_add(lifetime)
                    .and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok())
                    .map(|t| t.as_secs())
                    .unwrap_or(u64::max_value())
                    .into(),
            ),
        )
    }

    /// 指定上传凭证过期时间
    pub fn token_deadline(&mut self, deadline: SystemTime) -> &mut Self {
        self.set(
            DEADLINE_KEY.into(),
            JsonValue::Number(
                deadline
                    .duration_since(SystemTime::UNIX_EPOCH)
                    .ok()
                    .map(|t| t.as_secs())
                    .unwrap_or(u64::max_value())
                    .into(),
            ),
        )
    }

    /// 仅允许创建新的对象，不允许覆盖和修改同名对象
    pub fn insert_only(&mut self) -> &mut Self {
        self.set(INSERT_ONLY_KEY.into(), JsonValue::Number(1.into()))
    }

    /// 启用 MIME 类型自动检测
    pub fn enable_mime_detection(&mut self) -> &mut Self {
        self.set(DETECT_MIME_KEY.into(), JsonValue::Number(1.into()))
    }

    /// 禁用 MIME 类型自动检测
    pub fn disable_mime_detection(&mut self) -> &mut Self {
        self.unset(DETECT_MIME_KEY)
    }

    /// 设置文件类型
    pub fn file_type(&mut self, file_type: FileType) -> &mut Self {
        self.set(FILE_TYPE_KEY.into(), JsonValue::Number(u8::from(file_type).into()))
    }

    /// Web 端文件上传成功后，浏览器执行 303 跳转的 URL
    ///
    /// 通常用于表单上传。
    /// 文件上传成功后会跳转到 `<return_url>?upload_ret=<queryString>`，
    /// `<queryString>` 包含 `return_body()` 内容。
    /// 如不设置 `return_url`，则直接将 `return_body()` 的内容返回给客户端
    pub fn return_url(&mut self, url: impl Into<String>) -> &mut Self {
        self.set(RETURN_URL_KEY.into(), JsonValue::String(url.into()))
    }

    /// 上传成功后，自定义七牛云最终返回给上传端（在指定 `return_url()` 时是携带在跳转路径参数中）的数据
    ///
    /// 支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)。
    /// `return_body` 要求是合法的 JSON 文本。
    /// 例如 `{"key": $(key), "hash": $(etag), "w": $(imageInfo.width), "h": $(imageInfo.height)}`
    pub fn return_body(&mut self, body: impl Into<String>) -> &mut Self {
        self.set(RETURN_BODY_KEY.into(), JsonValue::String(body.into()))
    }

    /// 上传成功后，七牛云向业务服务器发送 POST 请求的 URL 列表，`Host`，回调请求的内容以及其 `Content-Type`
    ///
    /// 七牛服务器会在上传成功后逐一回调 URL 直到有一个成功为止
    ///
    /// 如果给出的 `host` 为空字符串，则使用默认的 `Host`
    ///
    /// `body` 参数必须不能为空，支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)
    //
    /// `body_type` 参数表示 `body` 参数的 `Content-Type`，如果为空，则为默认的 `application/x-www-form-urlencoded`
    pub fn callback<V: AsRef<[S]>, S: AsRef<str>>(
        &mut self,
        urls: V,
        host: impl Into<String>,
        body: impl Into<String>,
        body_type: impl Into<String>,
    ) -> &mut Self {
        self.set(CALLBACK_URL_KEY.into(), JsonValue::String(join_str_slice(urls, ";")));
        {
            let callback_host = host.into();
            if callback_host.is_empty() {
                self.unset(CALLBACK_HOST_KEY);
            } else {
                self.set(CALLBACK_HOST_KEY.into(), JsonValue::String(callback_host));
            }
        }
        self.set(CALLBACK_BODY_KEY.into(), JsonValue::String(body.into()));
        {
            let callback_body_type = body_type.into();
            if callback_body_type.is_empty() {
                self.unset(CALLBACK_BODY_TYPE_KEY);
            } else {
                self.set(CALLBACK_BODY_TYPE_KEY.into(), JsonValue::String(callback_body_type));
            }
        }
        self
    }

    /// 自定义对象名称
    ///
    /// 支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)。
    /// `force` 为 `false` 时，`save_as` 字段仅当用户上传的时候没有主动指定对象名时起作用，
    /// `force` 为 `true` 时，将强制按 `save_as` 字段的内容命名
    pub fn save_as(&mut self, save_as: impl Into<String>, force: bool) -> &mut Self {
        self.set(SAVE_KEY_KEY.into(), JsonValue::String(save_as.into()));
        if force {
            self.set(FORCE_SAVE_KEY_KEY.into(), JsonValue::Bool(true));
        } else {
            self.unset(FORCE_SAVE_KEY_KEY);
        }
        self
    }

    /// 限定上传文件尺寸的范围
    ///
    /// 单位为字节
    pub fn file_size_limitation(&mut self, size: impl RangeBounds<u64>) -> &mut Self {
        match size.start_bound() {
            Bound::Included(&s) => {
                self.set(FSIZE_MIN_KEY.into(), JsonValue::Number(s.into()));
            }
            Bound::Excluded(&s) => {
                self.set(FSIZE_MIN_KEY.into(), JsonValue::Number((s + 1).into()));
            }
            Bound::Unbounded => {
                self.unset(FSIZE_MIN_KEY);
            }
        }
        match size.end_bound() {
            Bound::Included(&s) => {
                self.set(FSIZE_LIMIT_KEY.into(), JsonValue::Number(s.into()));
            }
            Bound::Excluded(&s) => {
                self.set(FSIZE_LIMIT_KEY.into(), JsonValue::Number((s - 1).into()));
            }
            Bound::Unbounded => {
                self.unset(FSIZE_LIMIT_KEY);
            }
        }
        self
    }

    /// 限定用户上传的文件类型
    ///
    /// 指定本字段值，七牛服务器会侦测文件内容以判断 MIME 类型，再用判断值跟指定值进行匹配，
    /// 匹配成功则允许上传，匹配失败则返回 403 状态码
    pub fn mime_types<V: AsRef<[S]>, S: AsRef<str>>(&mut self, content_types: V) -> &mut Self {
        self.set(
            MIME_LIMIT_KEY.into(),
            JsonValue::String(join_str_slice(content_types, ";")),
        )
    }

    /// 对象生命周期
    ///
    /// 精确到天
    pub fn object_lifetime(&mut self, lifetime: Duration) -> &mut Self {
        let lifetime_secs = lifetime.as_secs();
        let secs_one_day = 60 * 60 * 24;

        self.set(
            DELETE_AFTER_DAYS_KEY.into(),
            lifetime_secs
                .checked_add(secs_one_day)
                .and_then(|s| s.checked_sub(1))
                .and_then(|s| s.checked_div(secs_one_day))
                .and_then(|s| s.try_into().ok())
                .unwrap_or_else(|| JsonValue::Number(u64::max_value().into())),
        )
    }

pub fn unset<Q>(&mut self, k: &Q) -> &mut Selfwhere
    String: Borrow<Q>,
    Q: ?Sized + Ord + Eq + Hash,

直接删除上传策略的键

Examples found in repository

src/upload_policy.rs (line 401)

    pub fn disable_mime_detection(&mut self) -> &mut Self {
        self.unset(DETECT_MIME_KEY)
    }

    /// 设置文件类型
    pub fn file_type(&mut self, file_type: FileType) -> &mut Self {
        self.set(FILE_TYPE_KEY.into(), JsonValue::Number(u8::from(file_type).into()))
    }

    /// Web 端文件上传成功后，浏览器执行 303 跳转的 URL
    ///
    /// 通常用于表单上传。
    /// 文件上传成功后会跳转到 `<return_url>?upload_ret=<queryString>`，
    /// `<queryString>` 包含 `return_body()` 内容。
    /// 如不设置 `return_url`，则直接将 `return_body()` 的内容返回给客户端
    pub fn return_url(&mut self, url: impl Into<String>) -> &mut Self {
        self.set(RETURN_URL_KEY.into(), JsonValue::String(url.into()))
    }

    /// 上传成功后，自定义七牛云最终返回给上传端（在指定 `return_url()` 时是携带在跳转路径参数中）的数据
    ///
    /// 支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)。
    /// `return_body` 要求是合法的 JSON 文本。
    /// 例如 `{"key": $(key), "hash": $(etag), "w": $(imageInfo.width), "h": $(imageInfo.height)}`
    pub fn return_body(&mut self, body: impl Into<String>) -> &mut Self {
        self.set(RETURN_BODY_KEY.into(), JsonValue::String(body.into()))
    }

    /// 上传成功后，七牛云向业务服务器发送 POST 请求的 URL 列表，`Host`，回调请求的内容以及其 `Content-Type`
    ///
    /// 七牛服务器会在上传成功后逐一回调 URL 直到有一个成功为止
    ///
    /// 如果给出的 `host` 为空字符串，则使用默认的 `Host`
    ///
    /// `body` 参数必须不能为空，支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)
    //
    /// `body_type` 参数表示 `body` 参数的 `Content-Type`，如果为空，则为默认的 `application/x-www-form-urlencoded`
    pub fn callback<V: AsRef<[S]>, S: AsRef<str>>(
        &mut self,
        urls: V,
        host: impl Into<String>,
        body: impl Into<String>,
        body_type: impl Into<String>,
    ) -> &mut Self {
        self.set(CALLBACK_URL_KEY.into(), JsonValue::String(join_str_slice(urls, ";")));
        {
            let callback_host = host.into();
            if callback_host.is_empty() {
                self.unset(CALLBACK_HOST_KEY);
            } else {
                self.set(CALLBACK_HOST_KEY.into(), JsonValue::String(callback_host));
            }
        }
        self.set(CALLBACK_BODY_KEY.into(), JsonValue::String(body.into()));
        {
            let callback_body_type = body_type.into();
            if callback_body_type.is_empty() {
                self.unset(CALLBACK_BODY_TYPE_KEY);
            } else {
                self.set(CALLBACK_BODY_TYPE_KEY.into(), JsonValue::String(callback_body_type));
            }
        }
        self
    }

    /// 自定义对象名称
    ///
    /// 支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)。
    /// `force` 为 `false` 时，`save_as` 字段仅当用户上传的时候没有主动指定对象名时起作用，
    /// `force` 为 `true` 时，将强制按 `save_as` 字段的内容命名
    pub fn save_as(&mut self, save_as: impl Into<String>, force: bool) -> &mut Self {
        self.set(SAVE_KEY_KEY.into(), JsonValue::String(save_as.into()));
        if force {
            self.set(FORCE_SAVE_KEY_KEY.into(), JsonValue::Bool(true));
        } else {
            self.unset(FORCE_SAVE_KEY_KEY);
        }
        self
    }

    /// 限定上传文件尺寸的范围
    ///
    /// 单位为字节
    pub fn file_size_limitation(&mut self, size: impl RangeBounds<u64>) -> &mut Self {
        match size.start_bound() {
            Bound::Included(&s) => {
                self.set(FSIZE_MIN_KEY.into(), JsonValue::Number(s.into()));
            }
            Bound::Excluded(&s) => {
                self.set(FSIZE_MIN_KEY.into(), JsonValue::Number((s + 1).into()));
            }
            Bound::Unbounded => {
                self.unset(FSIZE_MIN_KEY);
            }
        }
        match size.end_bound() {
            Bound::Included(&s) => {
                self.set(FSIZE_LIMIT_KEY.into(), JsonValue::Number(s.into()));
            }
            Bound::Excluded(&s) => {
                self.set(FSIZE_LIMIT_KEY.into(), JsonValue::Number((s - 1).into()));
            }
            Bound::Unbounded => {
                self.unset(FSIZE_LIMIT_KEY);
            }
        }
        self
    }

pub fn build(&self) -> UploadPolicy

生成上传策略

Examples found in repository

src/upload_policy.rs (line 565)

    pub fn build_token(&self, credential: Credential, opts: ToStringOptions) -> StaticUploadTokenProvider {
        self.build().into_static_upload_token_provider(credential, opts)
    }

src/upload_token.rs (line 454)

    fn make_policy(&self) -> AnyResult<UploadPolicy> {
        let mut builder =
            UploadPolicyBuilder::new_policy_for_bucket(self.bucket.to_string(), self.upload_token_lifetime);
        if let Some(on_policy_generated) = self.on_policy_generated.as_ref() {
            on_policy_generated(&mut builder)?;
        }
        Ok(builder.build())
    }
}

impl<C: Clone> Debug for BucketUploadTokenProvider<C> {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("BucketUploadTokenProvider")
            .field("bucket", &self.bucket)
            .field("upload_token_lifetime", &self.upload_token_lifetime)
            .finish()
    }
}

impl<C: CredentialProvider + Clone> UploadTokenProvider for BucketUploadTokenProvider<C> {
    #[inline]
    fn access_key(&self, _opts: GetAccessKeyOptions) -> ParseResult<GotAccessKey> {
        Ok(self
            .credential
            .get(Default::default())?
            .into_credential()
            .split()
            .0
            .into())
    }

    fn policy(&self, _opts: GetPolicyOptions) -> ParseResult<GotUploadPolicy<'_>> {
        Ok(self.make_policy()?.into())
    }

    fn to_token_string(&self, _opts: ToStringOptions) -> ToStringResult<Cow<'_, str>> {
        Ok(Cow::Owned(
            self.credential
                .get(Default::default())?
                .sign_with_data(self.make_policy()?.as_json().as_bytes()),
        ))
    }
}

/// 存储空间上传凭证构建器
#[derive(Clone)]
pub struct BucketUploadTokenProviderBuilder<C: Clone> {
    inner: BucketUploadTokenProvider<C>,
}

impl<C: Clone> BucketUploadTokenProviderBuilder<C> {
    /// 设置上传凭证回调函数
    #[inline]
    #[must_use]
    pub fn on_policy_generated(
        mut self,
        callback: impl Fn(&mut UploadPolicyBuilder) -> AnyResult<()> + Sync + Send + 'static,
    ) -> Self {
        self.inner.on_policy_generated = Some(Arc::new(callback));
        self
    }

    /// 构造存储空间上传凭证
    #[inline]
    pub fn build(self) -> BucketUploadTokenProvider<C> {
        self.inner
    }
}

impl<C: Clone> Debug for BucketUploadTokenProviderBuilder<C> {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("BucketUploadTokenProviderBuilder")
            .field("bucket", &self.inner.bucket)
            .field("upload_token_lifetime", &self.inner.upload_token_lifetime)
            .finish()
    }
}

/// 基于对象的动态生成
///
/// 根据对象的快速生成上传凭证实例
#[derive(Clone)]
pub struct ObjectUploadTokenProvider<C: Clone> {
    bucket: BucketName,
    object: ObjectName,
    upload_token_lifetime: Duration,
    credential: C,
    on_policy_generated: Option<OnPolicyGeneratedCallback>,
}

impl<C: Clone> ObjectUploadTokenProvider<C> {
    /// 基于存储空间和对象名称和认证信息动态生成上传凭证实例
    #[inline]
    pub fn new(
        bucket: impl Into<BucketName>,
        object: impl Into<ObjectName>,
        upload_token_lifetime: Duration,
        credential: C,
    ) -> Self {
        Self::builder(bucket, object, upload_token_lifetime, credential).build()
    }

    /// 创建对象上传凭证构建器
    #[inline]
    pub fn builder(
        bucket: impl Into<BucketName>,
        object: impl Into<ObjectName>,
        upload_token_lifetime: Duration,
        credential: C,
    ) -> ObjectUploadTokenProviderBuilder<C> {
        ObjectUploadTokenProviderBuilder {
            inner: Self {
                bucket: bucket.into(),
                object: object.into(),
                upload_token_lifetime,
                credential,
                on_policy_generated: None,
            },
        }
    }

    fn make_policy(&self) -> AnyResult<UploadPolicy> {
        let mut builder = UploadPolicyBuilder::new_policy_for_object(
            self.bucket.to_string(),
            self.object.to_string(),
            self.upload_token_lifetime,
        );
        if let Some(on_policy_generated) = self.on_policy_generated.as_ref() {
            on_policy_generated(&mut builder)?;
        }
        Ok(builder.build())
    }

pub fn build_token(
    &self,
    credential: Credential,
    opts: ToStringOptions
) -> StaticUploadTokenProvider

根据七牛认证信息直接生成上传凭证

pub fn reset(&mut self)

重置上传策略构建器

重置构建器使得构建器可以被多次复用

Trait Implementations

impl Clone for UploadPolicyBuilder

fn clone(&self) -> UploadPolicyBuilder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UploadPolicyBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<UploadPolicy> for UploadPolicyBuilder

fn from(policy: UploadPolicy) -> Self

Converts to this type from the input type.