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<&super::super::super::super::objects::api::rids::WorkspaceRid>,
180        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
181        body: impl conjure_http::client::WriteBody<O>,
182    ) -> Result<
183        super::super::super::super::objects::api::S3Path,
184        conjure_http::private::Error,
185    >;
186}
187/// The Upload Service manages file uploads to object storage.
188#[conjure_http::conjure_client(name = "UploadService")]
189pub trait AsyncUploadService<
190    #[request_writer]
191    O,
192    #[response_body]
193    I: conjure_http::private::Stream<
194            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
195        >,
196> {
197    /// Initiates a multipart upload to object storage.
198    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
199    #[endpoint(
200        method = POST,
201        path = "/upload/v1/multipart-upload",
202        name = "initiateMultipartUpload",
203        accept = conjure_http::client::StdResponseDeserializer
204    )]
205    async fn initiate_multipart_upload(
206        &self,
207        #[auth]
208        auth_: &conjure_object::BearerToken,
209        #[body(serializer = conjure_http::client::StdRequestSerializer)]
210        upload_request: &super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
211    ) -> Result<
212        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
213        conjure_http::private::Error,
214    >;
215    /// Lists the parts that have been uploaded for a given uploadId.
216    #[endpoint(
217        method = GET,
218        path = "/upload/v1/multipart-upload/{uploadId}",
219        name = "listParts",
220        accept = conjure_http::client::conjure::CollectionResponseDeserializer
221    )]
222    async fn list_parts(
223        &self,
224        #[auth]
225        auth_: &conjure_object::BearerToken,
226        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
227        upload_id: &str,
228        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
229        key: &str,
230        #[query(
231            name = "bucket",
232            encoder = conjure_http::client::conjure::PlainSeqEncoder
233        )]
234        bucket: Option<&str>,
235    ) -> Result<
236        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
237        conjure_http::private::Error,
238    >;
239    /// Signs an upload request for a single part.
240    /// Returns a URL that will execute the upload without further authentication.
241    #[endpoint(
242        method = POST,
243        path = "/upload/v1/multipart-upload/{uploadId}",
244        name = "signPart",
245        accept = conjure_http::client::StdResponseDeserializer
246    )]
247    async fn sign_part(
248        &self,
249        #[auth]
250        auth_: &conjure_object::BearerToken,
251        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
252        upload_id: &str,
253        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
254        key: &str,
255        #[query(
256            name = "partNumber",
257            encoder = conjure_http::client::conjure::PlainEncoder
258        )]
259        part_number: i32,
260        #[query(
261            name = "bucket",
262            encoder = conjure_http::client::conjure::PlainSeqEncoder
263        )]
264        bucket: Option<&str>,
265    ) -> Result<
266        super::super::super::super::objects::ingest::api::SignPartResponse,
267        conjure_http::private::Error,
268    >;
269    /// Completes a multipart upload to object storage.
270    /// This should be called after all parts have been uploaded.
271    /// Will throw EmptyMultipartUpload if there are 0 parts.
272    #[endpoint(
273        method = POST,
274        path = "/upload/v1/multipart-upload/{uploadId}/complete",
275        name = "completeMultipartUpload",
276        accept = conjure_http::client::StdResponseDeserializer
277    )]
278    async fn complete_multipart_upload(
279        &self,
280        #[auth]
281        auth_: &conjure_object::BearerToken,
282        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
283        upload_id: &str,
284        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
285        key: &str,
286        #[query(
287            name = "bucket",
288            encoder = conjure_http::client::conjure::PlainSeqEncoder
289        )]
290        bucket: Option<&str>,
291        #[body(serializer = conjure_http::client::StdRequestSerializer)]
292        parts: &[super::super::super::super::objects::ingest::api::Part],
293    ) -> Result<
294        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
295        conjure_http::private::Error,
296    >;
297    /// Aborts a multipart upload to S3.
298    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
299    #[endpoint(
300        method = POST,
301        path = "/upload/v1/multipart-upload/{uploadId}/abort",
302        name = "abortMultipartUpload",
303        accept = conjure_http::client::conjure::EmptyResponseDeserializer
304    )]
305    async fn abort_multipart_upload(
306        &self,
307        #[auth]
308        auth_: &conjure_object::BearerToken,
309        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
310        upload_id: &str,
311        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
312        key: &str,
313        #[query(
314            name = "bucket",
315            encoder = conjure_http::client::conjure::PlainSeqEncoder
316        )]
317        bucket: Option<&str>,
318    ) -> Result<(), conjure_http::private::Error>;
319    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
320    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
321    /// without giving that service any Scout credentials. The caller must be authorized to
322    /// read the workspace that owns the path (encoded as the first segment of the object key).
323    #[endpoint(
324        method = POST,
325        path = "/upload/v1/sign-download",
326        name = "signDownload",
327        accept = conjure_http::client::StdResponseDeserializer
328    )]
329    async fn sign_download(
330        &self,
331        #[auth]
332        auth_: &conjure_object::BearerToken,
333        #[body(serializer = conjure_http::client::StdRequestSerializer)]
334        request: &super::super::super::super::objects::ingest::api::SignDownloadRequest,
335    ) -> Result<
336        super::super::super::super::objects::ingest::api::SignDownloadResponse,
337        conjure_http::private::Error,
338    >;
339    /// Uploads a file to S3. Intended for smaller files.
340    #[endpoint(
341        method = POST,
342        path = "/upload/v1/upload-file",
343        name = "uploadFile",
344        accept = conjure_http::client::StdResponseDeserializer
345    )]
346    async fn upload_file(
347        &self,
348        #[auth]
349        auth_: &conjure_object::BearerToken,
350        #[query(
351            name = "fileName",
352            encoder = conjure_http::client::conjure::PlainEncoder
353        )]
354        file_name: &str,
355        #[query(
356            name = "sizeBytes",
357            encoder = conjure_http::client::conjure::PlainSeqEncoder
358        )]
359        size_bytes: Option<conjure_object::SafeLong>,
360        #[query(
361            name = "workspace",
362            encoder = conjure_http::client::conjure::PlainSeqEncoder
363        )]
364        workspace: Option<&super::super::super::super::objects::api::rids::WorkspaceRid>,
365        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
366        body: impl conjure_http::client::AsyncWriteBody<O> + Sync + Send,
367    ) -> Result<
368        super::super::super::super::objects::api::S3Path,
369        conjure_http::private::Error,
370    >;
371}
372/// The Upload Service manages file uploads to object storage.
373#[conjure_http::conjure_client(name = "UploadService", local)]
374pub trait LocalAsyncUploadService<
375    #[request_writer]
376    O,
377    #[response_body]
378    I: conjure_http::private::Stream<
379            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
380        >,
381> {
382    /// Initiates a multipart upload to object storage.
383    /// Returns an uploadId that should be used with listParts, signPart, and completeMultipartUpload.
384    #[endpoint(
385        method = POST,
386        path = "/upload/v1/multipart-upload",
387        name = "initiateMultipartUpload",
388        accept = conjure_http::client::StdResponseDeserializer
389    )]
390    async fn initiate_multipart_upload(
391        &self,
392        #[auth]
393        auth_: &conjure_object::BearerToken,
394        #[body(serializer = conjure_http::client::StdRequestSerializer)]
395        upload_request: &super::super::super::super::objects::ingest::api::InitiateMultipartUploadRequest,
396    ) -> Result<
397        super::super::super::super::objects::ingest::api::InitiateMultipartUploadResponse,
398        conjure_http::private::Error,
399    >;
400    /// Lists the parts that have been uploaded for a given uploadId.
401    #[endpoint(
402        method = GET,
403        path = "/upload/v1/multipart-upload/{uploadId}",
404        name = "listParts",
405        accept = conjure_http::client::conjure::CollectionResponseDeserializer
406    )]
407    async fn list_parts(
408        &self,
409        #[auth]
410        auth_: &conjure_object::BearerToken,
411        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
412        upload_id: &str,
413        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
414        key: &str,
415        #[query(
416            name = "bucket",
417            encoder = conjure_http::client::conjure::PlainSeqEncoder
418        )]
419        bucket: Option<&str>,
420    ) -> Result<
421        Vec<super::super::super::super::objects::ingest::api::PartWithSize>,
422        conjure_http::private::Error,
423    >;
424    /// Signs an upload request for a single part.
425    /// Returns a URL that will execute the upload without further authentication.
426    #[endpoint(
427        method = POST,
428        path = "/upload/v1/multipart-upload/{uploadId}",
429        name = "signPart",
430        accept = conjure_http::client::StdResponseDeserializer
431    )]
432    async fn sign_part(
433        &self,
434        #[auth]
435        auth_: &conjure_object::BearerToken,
436        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
437        upload_id: &str,
438        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
439        key: &str,
440        #[query(
441            name = "partNumber",
442            encoder = conjure_http::client::conjure::PlainEncoder
443        )]
444        part_number: i32,
445        #[query(
446            name = "bucket",
447            encoder = conjure_http::client::conjure::PlainSeqEncoder
448        )]
449        bucket: Option<&str>,
450    ) -> Result<
451        super::super::super::super::objects::ingest::api::SignPartResponse,
452        conjure_http::private::Error,
453    >;
454    /// Completes a multipart upload to object storage.
455    /// This should be called after all parts have been uploaded.
456    /// Will throw EmptyMultipartUpload if there are 0 parts.
457    #[endpoint(
458        method = POST,
459        path = "/upload/v1/multipart-upload/{uploadId}/complete",
460        name = "completeMultipartUpload",
461        accept = conjure_http::client::StdResponseDeserializer
462    )]
463    async fn complete_multipart_upload(
464        &self,
465        #[auth]
466        auth_: &conjure_object::BearerToken,
467        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
468        upload_id: &str,
469        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
470        key: &str,
471        #[query(
472            name = "bucket",
473            encoder = conjure_http::client::conjure::PlainSeqEncoder
474        )]
475        bucket: Option<&str>,
476        #[body(serializer = conjure_http::client::StdRequestSerializer)]
477        parts: &[super::super::super::super::objects::ingest::api::Part],
478    ) -> Result<
479        super::super::super::super::objects::ingest::api::CompleteMultipartUploadResponse,
480        conjure_http::private::Error,
481    >;
482    /// Aborts a multipart upload to S3.
483    /// Frees storage used by previously uploaded parts and prevents further uploads to the same uploadId.
484    #[endpoint(
485        method = POST,
486        path = "/upload/v1/multipart-upload/{uploadId}/abort",
487        name = "abortMultipartUpload",
488        accept = conjure_http::client::conjure::EmptyResponseDeserializer
489    )]
490    async fn abort_multipart_upload(
491        &self,
492        #[auth]
493        auth_: &conjure_object::BearerToken,
494        #[path(name = "uploadId", encoder = conjure_http::client::conjure::PlainEncoder)]
495        upload_id: &str,
496        #[query(name = "key", encoder = conjure_http::client::conjure::PlainEncoder)]
497        key: &str,
498        #[query(
499            name = "bucket",
500            encoder = conjure_http::client::conjure::PlainSeqEncoder
501        )]
502        bucket: Option<&str>,
503    ) -> Result<(), conjure_http::private::Error>;
504    /// Returns a short-lived signed GET URL for an object already in the uploads bucket.
505    /// Use this to hand a freshly-uploaded object's path to an external service (e.g. Dagger)
506    /// without giving that service any Scout credentials. The caller must be authorized to
507    /// read the workspace that owns the path (encoded as the first segment of the object key).
508    #[endpoint(
509        method = POST,
510        path = "/upload/v1/sign-download",
511        name = "signDownload",
512        accept = conjure_http::client::StdResponseDeserializer
513    )]
514    async fn sign_download(
515        &self,
516        #[auth]
517        auth_: &conjure_object::BearerToken,
518        #[body(serializer = conjure_http::client::StdRequestSerializer)]
519        request: &super::super::super::super::objects::ingest::api::SignDownloadRequest,
520    ) -> Result<
521        super::super::super::super::objects::ingest::api::SignDownloadResponse,
522        conjure_http::private::Error,
523    >;
524    /// Uploads a file to S3. Intended for smaller files.
525    #[endpoint(
526        method = POST,
527        path = "/upload/v1/upload-file",
528        name = "uploadFile",
529        accept = conjure_http::client::StdResponseDeserializer
530    )]
531    async fn upload_file(
532        &self,
533        #[auth]
534        auth_: &conjure_object::BearerToken,
535        #[query(
536            name = "fileName",
537            encoder = conjure_http::client::conjure::PlainEncoder
538        )]
539        file_name: &str,
540        #[query(
541            name = "sizeBytes",
542            encoder = conjure_http::client::conjure::PlainSeqEncoder
543        )]
544        size_bytes: Option<conjure_object::SafeLong>,
545        #[query(
546            name = "workspace",
547            encoder = conjure_http::client::conjure::PlainSeqEncoder
548        )]
549        workspace: Option<&super::super::super::super::objects::api::rids::WorkspaceRid>,
550        #[body(serializer = conjure_http::client::conjure::BinaryRequestSerializer)]
551        body: impl conjure_http::client::LocalAsyncWriteBody<O>,
552    ) -> Result<
553        super::super::super::super::objects::api::S3Path,
554        conjure_http::private::Error,
555    >;
556}
nominal_api_conjure/conjure/clients/upload/api/upload_service.rs

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