1 /*
2  * Copyright 2013 The Netty Project
3  *
4  * The Netty Project licenses this file to you under the Apache License,
5  * version 2.0 (the "License"); you may not use this file except in compliance
6  * with the License. You may obtain a copy of the License at:
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13  * License for the specific language governing permissions and limitations
14  * under the License.
15  */
16
17 package io.netty.buffer;
18
19 import io.netty.util.ResourceLeakDetector;
20 import io.netty.util.ResourceLeakTracker;
21 import io.netty.util.internal.ObjectUtil;
22
23 import java.nio.ByteOrder;
24
25 class SimpleLeakAwareByteBuf extends WrappedByteBuf {
26
27     /**
28      * This object's is associated with the {@link ResourceLeakTracker}. When {@link ResourceLeakTracker#close(Object)}
29      * is called this object will be used as the argument. It is also assumed that this object is used when
30      * {@link ResourceLeakDetector#track(Object)} is called to create {@link #leak}.
31      */
32     private final ByteBuf trackedByteBuf;
33     final ResourceLeakTracker<ByteBuf> leak;
34
35     SimpleLeakAwareByteBuf(ByteBuf wrapped, ByteBuf trackedByteBuf, ResourceLeakTracker<ByteBuf> leak) {
36         super(wrapped);
37         this.trackedByteBuf = ObjectUtil.checkNotNull(trackedByteBuf, "trackedByteBuf");
38         this.leak = ObjectUtil.checkNotNull(leak, "leak");
39     }
40
41     SimpleLeakAwareByteBuf(ByteBuf wrapped, ResourceLeakTracker<ByteBuf> leak) {
42         this(wrapped, wrapped, leak);
43     }
44
45     @Override
46     public ByteBuf slice() {
47         return newSharedLeakAwareByteBuf(super.slice());
48     }
49
50     @Override
51     public ByteBuf retainedSlice() {
52         return unwrappedDerived(super.retainedSlice());
53     }
54
55     @Override
56     public ByteBuf retainedSlice(int index, int length) {
57         return unwrappedDerived(super.retainedSlice(index, length));
58     }
59
60     @Override
61     public ByteBuf retainedDuplicate() {
62         return unwrappedDerived(super.retainedDuplicate());
63     }
64
65     @Override
66     public ByteBuf readRetainedSlice(int length) {
67         return unwrappedDerived(super.readRetainedSlice(length));
68     }
69
70     @Override
71     public ByteBuf slice(int index, int length) {
72         return newSharedLeakAwareByteBuf(super.slice(index, length));
73     }
74
75     @Override
76     public ByteBuf duplicate() {
77         return newSharedLeakAwareByteBuf(super.duplicate());
78     }
79
80     @Override
81     public ByteBuf readSlice(int length) {
82         return newSharedLeakAwareByteBuf(super.readSlice(length));
83     }
84
85     @Override
86     public ByteBuf asReadOnly() {
87         return newSharedLeakAwareByteBuf(super.asReadOnly());
88     }
89
90     @Override
91     public ByteBuf touch() {
92         return this;
93     }
94
95     @Override
96     public ByteBuf touch(Object hint) {
97         return this;
98     }
99
100     @Override
101     public boolean release() {
102         if (super.release()) {
103             closeLeak();
104             return true;
105         }
106         return false;
107     }
108
109     @Override
110     public boolean release(int decrement) {
111         if (super.release(decrement)) {
112             closeLeak();
113             return true;
114         }
115         return false;
116     }
117
118     private void closeLeak() {
119         // Close the ResourceLeakTracker with the tracked ByteBuf as argument. This must be the same that was used when
120         // calling DefaultResourceLeak.track(...).
121         boolean closed = leak.close(trackedByteBuf);
122         assert closed;
123     }
124
125     @Override
126     public ByteBuf order(ByteOrder endianness) {
127         if (order() == endianness) {
128             return this;
129         } else {
130             return newSharedLeakAwareByteBuf(super.order(endianness));
131         }
132     }
133
134     private ByteBuf unwrappedDerived(ByteBuf derived) {
135         // We only need to unwrap SwappedByteBuf implementations as these will be the only ones that may end up in
136         // the AbstractLeakAwareByteBuf implementations beside slices / duplicates and "real" buffers.
137         ByteBuf unwrappedDerived = unwrapSwapped(derived);
138
139         if (unwrappedDerived instanceof AbstractPooledDerivedByteBuf) {
140             // Update the parent to point to this buffer so we correctly close the ResourceLeakTracker.
141             ((AbstractPooledDerivedByteBuf) unwrappedDerived).parent(this);
142
143             ResourceLeakTracker<ByteBuf> newLeak = AbstractByteBuf.leakDetector.track(derived);
144             if (newLeak == null) {
145                 // No leak detection, just return the derived buffer.
146                 return derived;
147             }
148             return newLeakAwareByteBuf(derived, newLeak);
149         }
150         return newSharedLeakAwareByteBuf(derived);
151     }
152
153     @SuppressWarnings("deprecation")
154     private static ByteBuf unwrapSwapped(ByteBuf buf) {
155         if (buf instanceof SwappedByteBuf) {
156             do {
157                 buf = buf.unwrap();
158             } while (buf instanceof SwappedByteBuf);
159
160             return buf;
161         }
162         return buf;
163     }
164
165     private SimpleLeakAwareByteBuf newSharedLeakAwareByteBuf(
166             ByteBuf wrapped) {
167         return newLeakAwareByteBuf(wrapped, trackedByteBuf, leak);
168     }
169
170     private SimpleLeakAwareByteBuf newLeakAwareByteBuf(
171             ByteBuf wrapped, ResourceLeakTracker<ByteBuf> leakTracker) {
172         return newLeakAwareByteBuf(wrapped, wrapped, leakTracker);
173     }
174
175     protected SimpleLeakAwareByteBuf newLeakAwareByteBuf(
176             ByteBuf buf, ByteBuf trackedByteBuf, ResourceLeakTracker<ByteBuf> leakTracker) {
177         return new SimpleLeakAwareByteBuf(buf, trackedByteBuf, leakTracker);
178     }
179 }
180