Esempio n. 1
0
        public async Task <ObjectID> PutObject(CancellationToken context, PutObjectParams param, CallOptions options = null)
        {
            var object_client = new ObjectService.ObjectServiceClient(channel);
            var obj           = param.Object;
            var call          = object_client.Put(cancellationToken: context);
            var opts          = DefaultCallOptions.ApplyCustomOptions(options);
            var req_stream    = call.RequestStream;

            var req  = new PutRequest();
            var body = new PutRequest.Types.Body();

            req.Body = body;
            var address = new Address
            {
                ContainerId = obj.Header.ContainerId,
                ObjectId    = obj.ObjectId,
            };
            var meta = opts.GetRequestMetaHeader();

            AttachObjectSessionToken(opts, meta, address, ObjectSessionContext.Types.Verb.Put);
            req.MetaHeader = meta;
            var init = new PutRequest.Types.Body.Types.Init
            {
                ObjectId  = obj.ObjectId,
                Signature = obj.Signature,
                Header    = obj.Header,
            };

            req.Body.Init = init;
            req.SignRequest(key);

            await req_stream.WriteAsync(req);

            int offset = 0;

            while (offset < obj.Payload.Length)
            {
                var end        = offset + Object.Object.ChunkSize > obj.Payload.Length ? obj.Payload.Length : offset + Object.Object.ChunkSize;
                var chunk      = ByteString.CopyFrom(obj.Payload.ToByteArray()[offset..end]);
Esempio n. 2
0
        public async Task <Object.Object> GetObject(CancellationToken context, GetObjectParams param, CallOptions options = null)
        {
            var object_client  = new ObjectService.ObjectServiceClient(channel);
            var object_address = param.Address;
            var opts           = DefaultCallOptions.ApplyCustomOptions(options);
            var req            = new GetRequest
            {
                Body = new GetRequest.Types.Body
                {
                    Raw     = param.Raw,
                    Address = object_address,
                }
            };
            var meta = opts.GetRequestMetaHeader();

            AttachObjectSessionToken(opts, meta, object_address, ObjectSessionContext.Types.Verb.Get);
            req.MetaHeader = meta;
            req.SignRequest(key);

            var stream  = object_client.Get(req, cancellationToken: context).ResponseStream;
            var obj     = new Object.Object();
            var payload = new byte[] { };
            int offset  = 0;

            while (await stream.MoveNext())
            {
                var resp = stream.Current;
                if (!resp.VerifyResponse())
                {
                    throw new InvalidOperationException("invalid object get response");
                }
                switch (resp.Body.ObjectPartCase)
                {
                case GetResponse.Types.Body.ObjectPartOneofCase.Init:
                {
                    obj.ObjectId  = resp.Body.Init.ObjectId;
                    obj.Signature = resp.Body.Init.Signature;
                    obj.Header    = resp.Body.Init.Header;
                    payload       = new byte[obj.Header.PayloadLength];
                    break;
                }

                case GetResponse.Types.Body.ObjectPartOneofCase.Chunk:
                {
                    resp.Body.Chunk.CopyTo(payload, offset);
                    offset += resp.Body.Chunk.Length;
                    break;
                }

                case GetResponse.Types.Body.ObjectPartOneofCase.SplitInfo:
                {
                    throw new SplitInfoException(resp.Body.SplitInfo);
                }

                default:
                    throw new FormatException("malformed object get reponse");
                }
            }
            obj.Payload = ByteString.CopyFrom(payload);
            return(obj);
        }