/*
* Copyright © 2014 Cask Data, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package co.cask.cdap.common.twill;
import co.cask.cdap.common.conf.CConfiguration;
import co.cask.cdap.common.conf.Constants;
import co.cask.cdap.proto.Containers;
import co.cask.cdap.proto.SystemServiceLiveInfo;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import org.apache.twill.api.ResourceReport;
import org.apache.twill.api.TwillController;
import org.apache.twill.api.TwillRunResources;
import org.apache.twill.api.TwillRunnerService;
import org.apache.twill.discovery.Discoverable;
import org.apache.twill.discovery.DiscoveryServiceClient;
import org.jboss.netty.handler.codec.http.HttpResponseStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.HttpURLConnection;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.util.Collection;
import java.util.concurrent.TimeUnit;
/**
* Abstract class that can be extended by individual CDAP Services to implement their management methods.
*/
public abstract class AbstractDistributedMasterServiceManager implements MasterServiceManager {
private static final Logger LOG = LoggerFactory.getLogger(AbstractDistributedMasterServiceManager.class);
private static final long SERVICE_PING_RESPONSE_TIMEOUT = TimeUnit.MILLISECONDS.convert(1, TimeUnit.SECONDS);
protected final long discoveryTimeout;
protected CConfiguration cConf;
protected TwillRunnerService twillRunnerService;
protected String serviceName;
protected DiscoveryServiceClient discoveryServiceClient;
public AbstractDistributedMasterServiceManager(CConfiguration cConf, String serviceName,
TwillRunnerService twillRunnerService,
DiscoveryServiceClient discoveryServiceClient) {
this.cConf = cConf;
this.serviceName = serviceName;
this.twillRunnerService = twillRunnerService;
this.discoveryTimeout = cConf.getLong(Constants.Monitor.DISCOVERY_TIMEOUT_SECONDS);
this.discoveryServiceClient = discoveryServiceClient;
}
@Override
public SystemServiceLiveInfo getLiveInfo() {
SystemServiceLiveInfo.Builder builder = SystemServiceLiveInfo.builder();
Iterable<TwillController> twillControllerList = twillRunnerService.lookup(Constants.Service.MASTER_SERVICES);
if (twillControllerList == null) {
return builder.build();
}
for (TwillController twillController : twillControllerList) {
if (twillController.getResourceReport() == null) {
continue;
}
ResourceReport resourceReport = twillController.getResourceReport();
Collection<TwillRunResources> runResources = resourceReport.getResources().get(serviceName);
for (TwillRunResources resources : runResources) {
Containers.ContainerInfo containerInfo = new Containers.ContainerInfo(
Containers.ContainerType.SYSTEM_SERVICE,
serviceName,
resources.getInstanceId(),
resources.getContainerId(),
resources.getHost(),
resources.getMemoryMB(),
resources.getVirtualCores(),
resources.getDebugPort());
builder.addContainer(containerInfo);
}
}
return builder.build();
}
@Override
public int getInstances() {
Iterable<TwillController> twillControllerList = twillRunnerService.lookup(Constants.Service.MASTER_SERVICES);
int instances = 0;
if (twillControllerList != null) {
for (TwillController twillController : twillControllerList) {
if (twillController.getResourceReport() != null) {
instances = twillController.getResourceReport().getRunnableResources(serviceName).size();
}
}
}
return instances;
}
public boolean isServiceEnabled() {
// By default all the services are enabled. extending classes can override if the behavior should be different.
return true;
}
@Override
public boolean setInstances(int instanceCount) {
Preconditions.checkArgument(instanceCount > 0);
try {
Iterable<TwillController> twillControllerList = twillRunnerService.lookup(Constants.Service.MASTER_SERVICES);
if (twillControllerList != null) {
for (TwillController twillController : twillControllerList) {
twillController.changeInstances(serviceName, instanceCount).get();
}
}
return true;
} catch (Throwable t) {
LOG.error("Could not change service instance of {} : {}", serviceName, t.getMessage(), t);
return false;
}
}
@Override
public int getMinInstances() {
return 1;
}
@Override
public boolean canCheckStatus() {
return true;
}
@Override
public boolean isLogAvailable() {
return true;
}
@Override
public boolean isServiceAvailable() {
String url = null;
try {
Iterable<Discoverable> discoverables = this.discoveryServiceClient.discover(getDiscoverableName());
for (Discoverable discoverable : discoverables) {
//Ping the discovered service to check its status.
url = String.format("http://%s:%d/ping", discoverable.getSocketAddress().getHostName(),
discoverable.getSocketAddress().getPort());
if (checkGetStatus(url).equals(HttpResponseStatus.OK)) {
return true;
}
}
return false;
} catch (IllegalArgumentException e) {
return false;
} catch (Exception e) {
LOG.warn("Unable to ping {} at {} : Reason : {}", serviceName, url, e.getMessage());
return false;
}
}
protected String getDiscoverableName() {
return serviceName;
}
protected final HttpResponseStatus checkGetStatus(String url) throws Exception {
HttpURLConnection httpConn = null;
try {
httpConn = (HttpURLConnection) new URL(url).openConnection();
httpConn.setConnectTimeout((int) SERVICE_PING_RESPONSE_TIMEOUT);
httpConn.setReadTimeout((int) SERVICE_PING_RESPONSE_TIMEOUT);
return (HttpResponseStatus.valueOf(httpConn.getResponseCode()));
} catch (SocketTimeoutException e) {
return HttpResponseStatus.NOT_FOUND;
} finally {
if (httpConn != null) {
httpConn.disconnect();
}
}
}
@Override
public void restartAllInstances() {
Iterable<TwillController> twillControllers = twillRunnerService.lookup(Constants.Service.MASTER_SERVICES);
for (TwillController twillController : twillControllers) {
// Call restart instances
Futures.getUnchecked(twillController.restartAllInstances(serviceName));
}
}
@Override
public void restartInstances(int instanceId, int... moreInstanceIds) {
Iterable<TwillController> twillControllers = twillRunnerService.lookup(Constants.Service.MASTER_SERVICES);
for (TwillController twillController : twillControllers) {
// Call restart instances
Futures.getUnchecked(twillController.restartInstances(serviceName, instanceId, moreInstanceIds));
}
}
}