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 int maxDeadServers;
47
48
49 private int numProcessing;
50
51 public DeadServer(int maxDeadServers) {
52 super();
53 this.maxDeadServers = maxDeadServers;
54 this.numProcessing = 0;
55 }
56
57
58
59
60
61 public boolean isDeadServer(final String serverName) {
62 return isDeadServer(serverName, false);
63 }
64
65
66
67
68
69
70
71 public boolean cleanPreviousInstance(final String newServerName) {
72
73 String serverAddress =
74 HServerInfo.getServerNameLessStartCode(newServerName);
75 for (String serverName: deadServers) {
76 String deadServerAddress =
77 HServerInfo.getServerNameLessStartCode(serverName);
78 if (deadServerAddress.equals(serverAddress)) {
79 remove(serverName);
80 return true;
81 }
82 }
83 return false;
84 }
85
86
87
88
89
90
91
92
93
94 boolean isDeadServer(final String serverName, final boolean hostAndPortOnly) {
95 return HServerInfo.isServer(this, serverName, hostAndPortOnly);
96 }
97
98
99
100
101
102
103
104 public boolean areDeadServersInProgress() {
105 return numProcessing != 0;
106 }
107
108 public synchronized Set<String> clone() {
109 Set<String> clone = new HashSet<String>(this.deadServers.size());
110 clone.addAll(this.deadServers);
111 return clone;
112 }
113
114 public synchronized boolean add(String e) {
115 this.numProcessing++;
116 return deadServers.add(e);
117 }
118
119 public synchronized void finish(String e) {
120 this.numProcessing--;
121 }
122
123 public synchronized int size() {
124 return deadServers.size();
125 }
126
127 public synchronized boolean isEmpty() {
128 return deadServers.isEmpty();
129 }
130
131 public synchronized boolean contains(Object o) {
132 return deadServers.contains(o);
133 }
134
135 public Iterator<String> iterator() {
136 return this.deadServers.iterator();
137 }
138
139 public synchronized Object[] toArray() {
140 return deadServers.toArray();
141 }
142
143 public synchronized <T> T[] toArray(T[] a) {
144 return deadServers.toArray(a);
145 }
146
147 public synchronized boolean remove(Object o) {
148 return this.deadServers.remove(o);
149 }
150
151 public synchronized boolean containsAll(Collection<?> c) {
152 return deadServers.containsAll(c);
153 }
154
155 public synchronized boolean addAll(Collection<? extends String> c) {
156 return deadServers.addAll(c);
157 }
158
159 public synchronized boolean retainAll(Collection<?> c) {
160 return deadServers.retainAll(c);
161 }
162
163 public synchronized boolean removeAll(Collection<?> c) {
164 return deadServers.removeAll(c);
165 }
166
167 public synchronized void clear() {
168 throw new NotImplementedException();
169 }
170
171 public synchronized boolean equals(Object o) {
172 return deadServers.equals(o);
173 }
174
175 public synchronized int hashCode() {
176 return deadServers.hashCode();
177 }
178
179 public synchronized String toString() {
180 return this.deadServers.toString();
181 }
182 }