nominal_api_conjure/conjure/clients/upload/api/
upload_service.rs

1use conjure_http::endpoint;
2/// The Upload Service manages file uploads to object storage.
3#[conjure_http::conjure_client(name = "UploadService")]
4pub trait UploadService<
5    #[request_writer]
6    O,
7    #[response_body]
8    I: Iterator<
9            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
10        >,
11> {
12    /// Initiates a multipart upload to object storage.
13    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
14    #[endpoint(
15        method = POST,
16        path = "/upload/v1/multipart-upload",
17        name = "initiateMultipartUpload",
18        accept = conjure_http::client::StdResponseDeserializer
19    )]
20    fn initiate_multipart_upload(
21        &self,
22        #[auth]
23        auth_: &conjure_object::BearerToken,
24        #[body(serializer = conjure_http::client::StdRequestSerializer)]
25        upload_request: &super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
26    ) -> Result<
27        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
28        conjure_http::private::Error,
29    >;
30    /// Lists the parts that have been uploaded for a given uploadId.
31    #[endpoint(
32        method = GET,
33        path = "/upload/v1/multipart-upload/{uploadId}",
34        name = "listParts",
35        accept = conjure_http::client::conjure::CollectionResponseDeserializer
36    )]
37    fn list_parts(
38        &self,
39        #[auth]
40        auth_: &conjure_object::BearerToken,
41        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
42        upload_id: &str,
43        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
44        key: &str,
45        #[query(
46            name = "bucket",
47            encoder = conjure_http::client::conjure::PlainSeqEncoder
48        )]
49        bucket: Option<&str>,
50    ) -> Result<
51        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
52        conjure_http::private::Error,
53    >;
54    /// Signs an upload request for a single part.
55    /// Returns a URL that will execute the upload without further authentication.
56    #[endpoint(
57        method = POST,
58        path = "/upload/v1/multipart-upload/{uploadId}",
59        name = "signPart",
60        accept = conjure_http::client::StdResponseDeserializer
61    )]
62    fn sign_part(
63        &self,
64        #[auth]
65        auth_: &conjure_object::BearerToken,
66        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
67        upload_id: &str,
68        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
69        key: &str,
70        #[query(
71            name = "partNumber",
72            encoder = conjure_http::client::conjure::PlainEncoder
73        )]
74        part_number: i32,
75        #[query(
76            name = "bucket",
77            encoder = conjure_http::client::conjure::PlainSeqEncoder
78        )]
79        bucket: Option<&str>,
80    ) -> Result<
81        super::super::super::super::objects::ingest::api::SignPartResponse,
82        conjure_http::private::Error,
83    >;
84    /// Completes a multipart upload to object storage.
85    /// This should be called after all parts have been uploaded.
86    /// Will throw EmptyMultipartUpload if there are 0 parts.
87    #[endpoint(
88        method = POST,
89        path = "/upload/v1/multipart-upload/{uploadId}/complete",
90        name = "completeMultipartUpload",
91        accept = conjure_http::client::StdResponseDeserializer
92    )]
93    fn complete_multipart_upload(
94        &self,
95        #[auth]
96        auth_: &conjure_object::BearerToken,
97        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
98        upload_id: &str,
99        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
100        key: &str,
101        #[query(
102            name = "bucket",
103            encoder = conjure_http::client::conjure::PlainSeqEncoder
104        )]
105        bucket: Option<&str>,
106        #[body(serializer = conjure_http::client::StdRequestSerializer)]
107        parts: &[super::super::super::super::objects::ingest::api::Part],
108    ) -> Result<
109        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
110        conjure_http::private::Error,
111    >;
112    /// Aborts a multipart upload to S3.
113    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
114    #[endpoint(
115        method = POST,
116        path = "/upload/v1/multipart-upload/{uploadId}/abort",
117        name = "abortMultipartUpload",
118        accept = conjure_http::client::conjure::EmptyResponseDeserializer
119    )]
120    fn abort_multipart_upload(
121        &self,
122        #[auth]
123        auth_: &conjure_object::BearerToken,
124        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
125        upload_id: &str,
126        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
127        key: &str,
128        #[query(
129            name = "bucket",
130            encoder = conjure_http::client::conjure::PlainSeqEncoder
131        )]
132        bucket: Option<&str>,
133    ) -> Result<(), conjure_http::private::Error>;
134    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
135    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
136    /// without giving that service any Scout credentials. The caller must be authorized to
137    /// read the workspace that owns the path (encoded as the first segment of the object key).
138    #[endpoint(
139        method = POST,
140        path = "/upload/v1/sign-download",
141        name = "signDownload",
142        accept = conjure_http::client::StdResponseDeserializer
143    )]
144    fn sign_download(
145        &self,
146        #[auth]
147        auth_: &conjure_object::BearerToken,
148        #[body(serializer = conjure_http::client::StdRequestSerializer)]
149        request: &super::super::super::super::objects::ingest::api::SignDownloadRequest,
150    ) -> Result<
151        super::super::super::super::objects::ingest::api::SignDownloadResponse,
152        conjure_http::private::Error,
153    >;
154    /// Uploads a file to S3. Intended for smaller files.
155    #[endpoint(
156        method = POST,
157        path = "/upload/v1/upload-file",
158        name = "uploadFile",
159        accept = conjure_http::client::StdResponseDeserializer
160    )]
161    fn upload_file(
162        &self,
163        #[auth]
164        auth_: &conjure_object::BearerToken,
165        #[query(
166            name = "fileName",
167            encoder = conjure_http::client::conjure::PlainEncoder
168        )]
169        file_name: &str,
170        #[query(
171            name = "sizeBytes",
172            encoder = conjure_http::client::conjure::PlainSeqEncoder
173        )]
174        size_bytes: Option<conjure_object::SafeLong>,
175        #[query(
176            name = "workspace",
177            encoder = conjure_http::client::conjure::PlainSeqEncoder
178        )]
179        workspace: Option<&conjure_object::ResourceIdentifier>,
180        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
181        body: impl conjure_http::client::WriteBody<O>,
182    ) -> Result<String, conjure_http::private::Error>;
183}
184/// The Upload Service manages file uploads to object storage.
185#[conjure_http::conjure_client(name = "UploadService")]
186pub trait AsyncUploadService<
187    #[request_writer]
188    O,
189    #[response_body]
190    I: conjure_http::private::Stream<
191            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
192        >,
193> {
194    /// Initiates a multipart upload to object storage.
195    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
196    #[endpoint(
197        method = POST,
198        path = "/upload/v1/multipart-upload",
199        name = "initiateMultipartUpload",
200        accept = conjure_http::client::StdResponseDeserializer
201    )]
202    async fn initiate_multipart_upload(
203        &self,
204        #[auth]
205        auth_: &conjure_object::BearerToken,
206        #[body(serializer = conjure_http::client::StdRequestSerializer)]
207        upload_request: &super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
208    ) -> Result<
209        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
210        conjure_http::private::Error,
211    >;
212    /// Lists the parts that have been uploaded for a given uploadId.
213    #[endpoint(
214        method = GET,
215        path = "/upload/v1/multipart-upload/{uploadId}",
216        name = "listParts",
217        accept = conjure_http::client::conjure::CollectionResponseDeserializer
218    )]
219    async fn list_parts(
220        &self,
221        #[auth]
222        auth_: &conjure_object::BearerToken,
223        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
224        upload_id: &str,
225        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
226        key: &str,
227        #[query(
228            name = "bucket",
229            encoder = conjure_http::client::conjure::PlainSeqEncoder
230        )]
231        bucket: Option<&str>,
232    ) -> Result<
233        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
234        conjure_http::private::Error,
235    >;
236    /// Signs an upload request for a single part.
237    /// Returns a URL that will execute the upload without further authentication.
238    #[endpoint(
239        method = POST,
240        path = "/upload/v1/multipart-upload/{uploadId}",
241        name = "signPart",
242        accept = conjure_http::client::StdResponseDeserializer
243    )]
244    async fn sign_part(
245        &self,
246        #[auth]
247        auth_: &conjure_object::BearerToken,
248        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
249        upload_id: &str,
250        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
251        key: &str,
252        #[query(
253            name = "partNumber",
254            encoder = conjure_http::client::conjure::PlainEncoder
255        )]
256        part_number: i32,
257        #[query(
258            name = "bucket",
259            encoder = conjure_http::client::conjure::PlainSeqEncoder
260        )]
261        bucket: Option<&str>,
262    ) -> Result<
263        super::super::super::super::objects::ingest::api::SignPartResponse,
264        conjure_http::private::Error,
265    >;
266    /// Completes a multipart upload to object storage.
267    /// This should be called after all parts have been uploaded.
268    /// Will throw EmptyMultipartUpload if there are 0 parts.
269    #[endpoint(
270        method = POST,
271        path = "/upload/v1/multipart-upload/{uploadId}/complete",
272        name = "completeMultipartUpload",
273        accept = conjure_http::client::StdResponseDeserializer
274    )]
275    async fn complete_multipart_upload(
276        &self,
277        #[auth]
278        auth_: &conjure_object::BearerToken,
279        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
280        upload_id: &str,
281        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
282        key: &str,
283        #[query(
284            name = "bucket",
285            encoder = conjure_http::client::conjure::PlainSeqEncoder
286        )]
287        bucket: Option<&str>,
288        #[body(serializer = conjure_http::client::StdRequestSerializer)]
289        parts: &[super::super::super::super::objects::ingest::api::Part],
290    ) -> Result<
291        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
292        conjure_http::private::Error,
293    >;
294    /// Aborts a multipart upload to S3.
295    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
296    #[endpoint(
297        method = POST,
298        path = "/upload/v1/multipart-upload/{uploadId}/abort",
299        name = "abortMultipartUpload",
300        accept = conjure_http::client::conjure::EmptyResponseDeserializer
301    )]
302    async fn abort_multipart_upload(
303        &self,
304        #[auth]
305        auth_: &conjure_object::BearerToken,
306        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
307        upload_id: &str,
308        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
309        key: &str,
310        #[query(
311            name = "bucket",
312            encoder = conjure_http::client::conjure::PlainSeqEncoder
313        )]
314        bucket: Option<&str>,
315    ) -> Result<(), conjure_http::private::Error>;
316    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
317    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
318    /// without giving that service any Scout credentials. The caller must be authorized to
319    /// read the workspace that owns the path (encoded as the first segment of the object key).
320    #[endpoint(
321        method = POST,
322        path = "/upload/v1/sign-download",
323        name = "signDownload",
324        accept = conjure_http::client::StdResponseDeserializer
325    )]
326    async fn sign_download(
327        &self,
328        #[auth]
329        auth_: &conjure_object::BearerToken,
330        #[body(serializer = conjure_http::client::StdRequestSerializer)]
331        request: &super::super::super::super::objects::ingest::api::SignDownloadRequest,
332    ) -> Result<
333        super::super::super::super::objects::ingest::api::SignDownloadResponse,
334        conjure_http::private::Error,
335    >;
336    /// Uploads a file to S3. Intended for smaller files.
337    #[endpoint(
338        method = POST,
339        path = "/upload/v1/upload-file",
340        name = "uploadFile",
341        accept = conjure_http::client::StdResponseDeserializer
342    )]
343    async fn upload_file(
344        &self,
345        #[auth]
346        auth_: &conjure_object::BearerToken,
347        #[query(
348            name = "fileName",
349            encoder = conjure_http::client::conjure::PlainEncoder
350        )]
351        file_name: &str,
352        #[query(
353            name = "sizeBytes",
354            encoder = conjure_http::client::conjure::PlainSeqEncoder
355        )]
356        size_bytes: Option<conjure_object::SafeLong>,
357        #[query(
358            name = "workspace",
359            encoder = conjure_http::client::conjure::PlainSeqEncoder
360        )]
361        workspace: Option<&conjure_object::ResourceIdentifier>,
362        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
363        body: impl conjure_http::client::AsyncWriteBody<O> + Sync + Send,
364    ) -> Result<String, conjure_http::private::Error>;
365}
366/// The Upload Service manages file uploads to object storage.
367#[conjure_http::conjure_client(name = "UploadService", local)]
368pub trait LocalAsyncUploadService<
369    #[request_writer]
370    O,
371    #[response_body]
372    I: conjure_http::private::Stream<
373            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
374        >,
375> {
376    /// Initiates a multipart upload to object storage.
377    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
378    #[endpoint(
379        method = POST,
380        path = "/upload/v1/multipart-upload",
381        name = "initiateMultipartUpload",
382        accept = conjure_http::client::StdResponseDeserializer
383    )]
384    async fn initiate_multipart_upload(
385        &self,
386        #[auth]
387        auth_: &conjure_object::BearerToken,
388        #[body(serializer = conjure_http::client::StdRequestSerializer)]
389        upload_request: &super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
390    ) -> Result<
391        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
392        conjure_http::private::Error,
393    >;
394    /// Lists the parts that have been uploaded for a given uploadId.
395    #[endpoint(
396        method = GET,
397        path = "/upload/v1/multipart-upload/{uploadId}",
398        name = "listParts",
399        accept = conjure_http::client::conjure::CollectionResponseDeserializer
400    )]
401    async fn list_parts(
402        &self,
403        #[auth]
404        auth_: &conjure_object::BearerToken,
405        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
406        upload_id: &str,
407        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
408        key: &str,
409        #[query(
410            name = "bucket",
411            encoder = conjure_http::client::conjure::PlainSeqEncoder
412        )]
413        bucket: Option<&str>,
414    ) -> Result<
415        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
416        conjure_http::private::Error,
417    >;
418    /// Signs an upload request for a single part.
419    /// Returns a URL that will execute the upload without further authentication.
420    #[endpoint(
421        method = POST,
422        path = "/upload/v1/multipart-upload/{uploadId}",
423        name = "signPart",
424        accept = conjure_http::client::StdResponseDeserializer
425    )]
426    async fn sign_part(
427        &self,
428        #[auth]
429        auth_: &conjure_object::BearerToken,
430        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
431        upload_id: &str,
432        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
433        key: &str,
434        #[query(
435            name = "partNumber",
436            encoder = conjure_http::client::conjure::PlainEncoder
437        )]
438        part_number: i32,
439        #[query(
440            name = "bucket",
441            encoder = conjure_http::client::conjure::PlainSeqEncoder
442        )]
443        bucket: Option<&str>,
444    ) -> Result<
445        super::super::super::super::objects::ingest::api::SignPartResponse,
446        conjure_http::private::Error,
447    >;
448    /// Completes a multipart upload to object storage.
449    /// This should be called after all parts have been uploaded.
450    /// Will throw EmptyMultipartUpload if there are 0 parts.
451    #[endpoint(
452        method = POST,
453        path = "/upload/v1/multipart-upload/{uploadId}/complete",
454        name = "completeMultipartUpload",
455        accept = conjure_http::client::StdResponseDeserializer
456    )]
457    async fn complete_multipart_upload(
458        &self,
459        #[auth]
460        auth_: &conjure_object::BearerToken,
461        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
462        upload_id: &str,
463        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
464        key: &str,
465        #[query(
466            name = "bucket",
467            encoder = conjure_http::client::conjure::PlainSeqEncoder
468        )]
469        bucket: Option<&str>,
470        #[body(serializer = conjure_http::client::StdRequestSerializer)]
471        parts: &[super::super::super::super::objects::ingest::api::Part],
472    ) -> Result<
473        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
474        conjure_http::private::Error,
475    >;
476    /// Aborts a multipart upload to S3.
477    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
478    #[endpoint(
479        method = POST,
480        path = "/upload/v1/multipart-upload/{uploadId}/abort",
481        name = "abortMultipartUpload",
482        accept = conjure_http::client::conjure::EmptyResponseDeserializer
483    )]
484    async fn abort_multipart_upload(
485        &self,
486        #[auth]
487        auth_: &conjure_object::BearerToken,
488        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
489        upload_id: &str,
490        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
491        key: &str,
492        #[query(
493            name = "bucket",
494            encoder = conjure_http::client::conjure::PlainSeqEncoder
495        )]
496        bucket: Option<&str>,
497    ) -> Result<(), conjure_http::private::Error>;
498    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
499    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
500    /// without giving that service any Scout credentials. The caller must be authorized to
501    /// read the workspace that owns the path (encoded as the first segment of the object key).
502    #[endpoint(
503        method = POST,
504        path = "/upload/v1/sign-download",
505        name = "signDownload",
506        accept = conjure_http::client::StdResponseDeserializer
507    )]
508    async fn sign_download(
509        &self,
510        #[auth]
511        auth_: &conjure_object::BearerToken,
512        #[body(serializer = conjure_http::client::StdRequestSerializer)]
513        request: &super::super::super::super::objects::ingest::api::SignDownloadRequest,
514    ) -> Result<
515        super::super::super::super::objects::ingest::api::SignDownloadResponse,
516        conjure_http::private::Error,
517    >;
518    /// Uploads a file to S3. Intended for smaller files.
519    #[endpoint(
520        method = POST,
521        path = "/upload/v1/upload-file",
522        name = "uploadFile",
523        accept = conjure_http::client::StdResponseDeserializer
524    )]
525    async fn upload_file(
526        &self,
527        #[auth]
528        auth_: &conjure_object::BearerToken,
529        #[query(
530            name = "fileName",
531            encoder = conjure_http::client::conjure::PlainEncoder
532        )]
533        file_name: &str,
534        #[query(
535            name = "sizeBytes",
536            encoder = conjure_http::client::conjure::PlainSeqEncoder
537        )]
538        size_bytes: Option<conjure_object::SafeLong>,
539        #[query(
540            name = "workspace",
541            encoder = conjure_http::client::conjure::PlainSeqEncoder
542        )]
543        workspace: Option<&conjure_object::ResourceIdentifier>,
544        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
545        body: impl conjure_http::client::LocalAsyncWriteBody<O>,
546    ) -> Result<String, conjure_http::private::Error>;
547}
nominal_api_conjure/conjure/clients/upload/api/upload_service.rs

nominal_api_conjure/conjure/clients/upload/api/
upload_service.rs
