← Back to branch summary

~ubuntu-branches/ubuntu/wily/grpc/wily

« back to all changes in this revision

Viewing changes to src/csharp/Grpc.Core/Internal/AsyncCallServer.cs

  • Committer: Package Import Robot
  • Author(s): Andrew Pollock
  • Date: 2015-05-07 13:28:11 UTC
  • Revision ID: package-import@ubuntu.com-20150507132811-ybm4hfq73tnvvd2e
Tags: upstream-0.10.0
Import upstream version 0.10.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/csharp/Grpc.Core/Internal/AsyncCallServer.cs
 
1
#region Copyright notice and license
 
2
 
 
3
// Copyright 2015, Google Inc.
 
4
// All rights reserved.
 
5
// 
 
6
// Redistribution and use in source and binary forms, with or without
 
7
// modification, are permitted provided that the following conditions are
 
8
// met:
 
9
// 
 
10
//     * Redistributions of source code must retain the above copyright
 
11
// notice, this list of conditions and the following disclaimer.
 
12
//     * Redistributions in binary form must reproduce the above
 
13
// copyright notice, this list of conditions and the following disclaimer
 
14
// in the documentation and/or other materials provided with the
 
15
// distribution.
 
16
//     * Neither the name of Google Inc. nor the names of its
 
17
// contributors may be used to endorse or promote products derived from
 
18
// this software without specific prior written permission.
 
19
// 
 
20
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
21
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
22
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
23
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
24
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
25
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
26
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
27
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
28
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
29
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
30
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
31
 
 
32
#endregion
 
33
 
 
34
using System;
 
35
using System.Diagnostics;
 
36
using System.Runtime.CompilerServices;
 
37
using System.Runtime.InteropServices;
 
38
using System.Threading;
 
39
using System.Threading.Tasks;
 
40
using Grpc.Core.Internal;
 
41
using Grpc.Core.Utils;
 
42
 
 
43
namespace Grpc.Core.Internal
 
44
{
 
45
    /// <summary>
 
46
    /// Manages server side native call lifecycle.
 
47
    /// </summary>
 
48
    internal class AsyncCallServer<TRequest, TResponse> : AsyncCallBase<TResponse, TRequest>
 
49
    {
 
50
        readonly TaskCompletionSource<object> finishedServersideTcs = new TaskCompletionSource<object>();
 
51
 
 
52
        public AsyncCallServer(Func<TResponse, byte[]> serializer, Func<byte[], TRequest> deserializer) : base(serializer, deserializer)
 
53
        {
 
54
        }
 
55
 
 
56
        public void Initialize(CallSafeHandle call)
 
57
        {
 
58
            DebugStats.ActiveServerCalls.Increment();
 
59
            InitializeInternal(call);
 
60
        }
 
61
 
 
62
        /// <summary>
 
63
        /// Starts a server side call.
 
64
        /// </summary>
 
65
        public Task ServerSideCallAsync()
 
66
        {
 
67
            lock (myLock)
 
68
            {
 
69
                Preconditions.CheckNotNull(call);
 
70
 
 
71
                started = true;
 
72
 
 
73
                call.StartServerSide(HandleFinishedServerside);
 
74
                return finishedServersideTcs.Task;
 
75
            }
 
76
        }
 
77
 
 
78
        /// <summary>
 
79
        /// Sends a streaming response. Only one pending send action is allowed at any given time.
 
80
        /// completionDelegate is called when the operation finishes.
 
81
        /// </summary>
 
82
        public void StartSendMessage(TResponse msg, AsyncCompletionDelegate<object> completionDelegate)
 
83
        {
 
84
            StartSendMessageInternal(msg, completionDelegate);
 
85
        }
 
86
 
 
87
        /// <summary>
 
88
        /// Receives a streaming request. Only one pending read action is allowed at any given time.
 
89
        /// completionDelegate is called when the operation finishes.
 
90
        /// </summary>
 
91
        public void StartReadMessage(AsyncCompletionDelegate<TRequest> completionDelegate)
 
92
        {
 
93
            StartReadMessageInternal(completionDelegate);
 
94
        }
 
95
 
 
96
        /// <summary>
 
97
        /// Sends call result status, also indicating server is done with streaming responses.
 
98
        /// Only one pending send action is allowed at any given time.
 
99
        /// completionDelegate is called when the operation finishes.
 
100
        /// </summary>
 
101
        public void StartSendStatusFromServer(Status status, AsyncCompletionDelegate<object> completionDelegate)
 
102
        {
 
103
            lock (myLock)
 
104
            {
 
105
                Preconditions.CheckNotNull(completionDelegate, "Completion delegate cannot be null");
 
106
                CheckSendingAllowed();
 
107
 
 
108
                call.StartSendStatusFromServer(status, HandleHalfclosed);
 
109
                halfcloseRequested = true;
 
110
                readingDone = true;
 
111
                sendCompletionDelegate = completionDelegate;
 
112
            }
 
113
        }
 
114
 
 
115
        protected override void OnReleaseResources()
 
116
        {
 
117
            DebugStats.ActiveServerCalls.Decrement();
 
118
        }
 
119
 
 
120
        /// <summary>
 
121
        /// Handles the server side close completion.
 
122
        /// </summary>
 
123
        private void HandleFinishedServerside(bool success, BatchContextSafeHandle ctx)
 
124
        {
 
125
            bool cancelled = ctx.GetReceivedCloseOnServerCancelled();
 
126
 
 
127
            lock (myLock)
 
128
            {
 
129
                finished = true;
 
130
 
 
131
                if (cancelled)
 
132
                {
 
133
                    // Once we cancel, we don't have to care that much 
 
134
                    // about reads and writes.
 
135
                    Cancel();
 
136
                }
 
137
 
 
138
                ReleaseResourcesIfPossible();
 
139
            }
 
140
            // TODO(jtattermusch): handle error
 
141
 
 
142
            finishedServersideTcs.SetResult(null);
 
143
        }
 
144
    }
 
145
}
 
 
b'\\ No newline at end of file'