1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.hadoop.hbase.master;
21
22 import java.util.Collection;
23 import java.util.HashSet;
24 import java.util.Iterator;
25 import java.util.LinkedList;
26 import java.util.List;
27 import java.util.Set;
28
29 import org.apache.commons.lang.NotImplementedException;
30 import org.apache.hadoop.hbase.HServerInfo;
31
32
33
34
35 public class DeadServer implements Set<String> {
36
37
38
39
40
41
42
43 private final Set<String> deadServers = new HashSet<String>();
44
45
46 private final List<String> deadServerList = new LinkedList<String>();
47
48
49 private final int maxDeadServers;
50
51
52 private int numProcessing;
53
54 public DeadServer(int maxDeadServers) {
55 super();
56 this.maxDeadServers = maxDeadServers;
57 this.numProcessing = 0;
58 }
59
60
61
62
63
64 public boolean isDeadServer(final String serverName) {
65 return isDeadServer(serverName, false);
66 }
67
68
69
70
71
72
73
74
75
76 boolean isDeadServer(final String serverName, final boolean hostAndPortOnly) {
77 return HServerInfo.isServer(this, serverName, hostAndPortOnly);
78 }
79
80
81
82
83
84
85
86 public boolean areDeadServersInProgress() {
87 return numProcessing != 0;
88 }
89
90 public synchronized Set<String> clone() {
91 Set<String> clone = new HashSet<String>(this.deadServers.size());
92 clone.addAll(this.deadServers);
93 return clone;
94 }
95
96 public synchronized boolean add(String e) {
97 this.numProcessing++;
98
99 if (deadServerList.size() == this.maxDeadServers) {
100 deadServers.remove(deadServerList.remove(0));
101 }
102 deadServerList.add(e);
103 return deadServers.add(e);
104 }
105
106 public synchronized void finish(String e) {
107 this.numProcessing--;
108 }
109
110 public synchronized int size() {
111 return deadServers.size();
112 }
113
114 public synchronized boolean isEmpty() {
115 return deadServers.isEmpty();
116 }
117
118 public synchronized boolean contains(Object o) {
119 return deadServers.contains(o);
120 }
121
122 public Iterator<String> iterator() {
123 return this.deadServers.iterator();
124 }
125
126 public synchronized Object[] toArray() {
127 return deadServers.toArray();
128 }
129
130 public synchronized <T> T[] toArray(T[] a) {
131 return deadServers.toArray(a);
132 }
133
134 public synchronized boolean remove(Object o) {
135 throw new UnsupportedOperationException();
136 }
137
138 public synchronized boolean containsAll(Collection<?> c) {
139 return deadServers.containsAll(c);
140 }
141
142 public synchronized boolean addAll(Collection<? extends String> c) {
143 return deadServers.addAll(c);
144 }
145
146 public synchronized boolean retainAll(Collection<?> c) {
147 return deadServers.retainAll(c);
148 }
149
150 public synchronized boolean removeAll(Collection<?> c) {
151 return deadServers.removeAll(c);
152 }
153
154 public synchronized void clear() {
155 throw new NotImplementedException();
156 }
157
158 public synchronized boolean equals(Object o) {
159 return deadServers.equals(o);
160 }
161
162 public synchronized int hashCode() {
163 return deadServers.hashCode();
164 }
165
166 public synchronized String toString() {
167 return this.deadServers.toString();
168 }
169 }