/*
* SonarQube
* Copyright (C) 2009-2017 SonarSource SA
* mailto:info AT sonarsource DOT com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package org.sonar.process;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
import org.apache.commons.io.IOUtils;
import static java.lang.String.format;
import static org.apache.commons.lang.StringUtils.rightPad;
import static org.sonar.process.ProcessCommands.MAX_PROCESSES;
/**
* Process inter-communication to :
* <ul>
* <li>share status of child process</li>
* <li>stop/restart child process</li>
* </ul>
*
* <p>
* It relies on a single file accessed by all processes through a {@link MappedByteBuffer}.<br/>
* Following alternatives were considered but not selected :
* <ul>
* <li>JMX beans over RMI: network issues (mostly because of Java reverse-DNS) + requires to configure and open a new port</li>
* <li>simple socket protocol: same drawbacks are RMI connection</li>
* <li>java.lang.Process#destroy(): shutdown hooks are not executed on some OS (mostly MSWindows)</li>
* <li>execute OS-specific commands (for instance kill on *nix): OS-specific, so hell to support. Moreover how to get identify a process ?</li>
* </ul>
* </p>
*
* <p>
* The file contains {@link ProcessCommands#MAX_PROCESSES} groups of {@link #BYTE_LENGTH_FOR_ONE_PROCESS} bits.
* Each group of byte is used as follow:
* <ul>
* <li>First byte contains {@link #EMPTY} until process is UP and writes {@link #UP}</li>
* <li>Second byte contains {@link #EMPTY} until any process requests current one to stop by writing value {@link #STOP}</li>
* <li>Third byte contains {@link #EMPTY} until any process requests current one to restart by writing value {@link #RESTART}.
* Process acknowledges restart by writing back {@link #EMPTY}</li>
* <li>Fourth byte will always contain {@link #EMPTY} unless process declares that it is operational by writing {@link #OPERATIONAL}.
* This does not imply that is done starting.</li>
* <li>The next 8 bytes contains a long (value of {@link System#currentTimeMillis()}) which represents the date of the last ping</li>
* </ul>
* </p>
*/
public class AllProcessesCommands implements AutoCloseable {
private static final int UP_BYTE_OFFSET = 0;
private static final int STOP_BYTE_OFFSET = 1;
private static final int RESTART_BYTE_OFFSET = 2;
private static final int OPERATIONAL_BYTE_OFFSET = 3;
private static final int PING_BYTE_OFFSET = 4;
private static final int SYSTEM_INFO_URL_BYTE_OFFSET = PING_BYTE_OFFSET + 8;
private static final int SYSTEM_INFO_URL_SIZE_IN_BYTES = 500;
private static final int BYTE_LENGTH_FOR_ONE_PROCESS = 1 + 1 + 1 + 1 + 8 + SYSTEM_INFO_URL_SIZE_IN_BYTES;
// With this shared memory we can handle up to MAX_PROCESSES processes
private static final int MAX_SHARED_MEMORY = BYTE_LENGTH_FOR_ONE_PROCESS * MAX_PROCESSES;
private static final byte STOP = (byte) 0xFF;
private static final byte RESTART = (byte) 0xAA;
private static final byte OPERATIONAL = (byte) 0x59;
private static final byte UP = (byte) 0x01;
private static final byte EMPTY = (byte) 0x00;
// VisibleForTesting
final MappedByteBuffer mappedByteBuffer;
private final RandomAccessFile sharedMemory;
public AllProcessesCommands(File directory) {
if (!directory.isDirectory() || !directory.exists()) {
throw new IllegalArgumentException("Not a valid directory: " + directory);
}
try {
sharedMemory = new RandomAccessFile(new File(directory, "sharedmemory"), "rw");
mappedByteBuffer = sharedMemory.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, MAX_SHARED_MEMORY);
} catch (IOException e) {
throw new IllegalArgumentException("Unable to create shared memory : ", e);
}
}
public void clean() {
for (int i = 0; i < MAX_PROCESSES; i++) {
cleanData(i);
}
}
public ProcessCommands create(int processNumber) {
return createForProcess(processNumber, false);
}
public ProcessCommands createAfterClean(int processNumber) {
return createForProcess(processNumber, true);
}
private ProcessCommands createForProcess(int processNumber, boolean clean) {
checkProcessNumber(processNumber);
ProcessCommands processCommands = new ProcessCommandsImpl(processNumber);
if (clean) {
cleanData(processNumber);
}
return processCommands;
}
boolean isUp(int processNumber) {
return readByte(processNumber, UP_BYTE_OFFSET) == UP;
}
/**
* To be executed by child process to declare that it is done starting
*/
void setUp(int processNumber) {
writeByte(processNumber, UP_BYTE_OFFSET, UP);
}
boolean isOperational(int processNumber) {
return readByte(processNumber, OPERATIONAL_BYTE_OFFSET) == OPERATIONAL;
}
/**
* To be executed by child process to declare that it is started and fully operational
*/
void setOperational(int processNumber) {
writeByte(processNumber, OPERATIONAL_BYTE_OFFSET, OPERATIONAL);
}
void ping(int processNumber) {
writeLong(processNumber, PING_BYTE_OFFSET, System.currentTimeMillis());
}
long getLastPing(int processNumber) {
return readLong(processNumber, PING_BYTE_OFFSET);
}
String getSystemInfoUrl(int processNumber) {
byte[] urlBytes = readBytes(processNumber, SYSTEM_INFO_URL_BYTE_OFFSET, SYSTEM_INFO_URL_SIZE_IN_BYTES);
return new String(urlBytes, StandardCharsets.US_ASCII).trim();
}
void setSystemInfoUrl(int processNumber, String url) {
byte[] urlBytes = rightPad(url, SYSTEM_INFO_URL_SIZE_IN_BYTES).getBytes(StandardCharsets.US_ASCII);
if (urlBytes.length > SYSTEM_INFO_URL_SIZE_IN_BYTES) {
throw new IllegalArgumentException(format("System Info URL is too long. Max is %d bytes. Got: %s", SYSTEM_INFO_URL_SIZE_IN_BYTES, url));
}
writeBytes(processNumber, SYSTEM_INFO_URL_BYTE_OFFSET, urlBytes);
}
/**
* To be executed by monitor process to ask for child process termination
*/
void askForStop(int processNumber) {
writeByte(processNumber, STOP_BYTE_OFFSET, STOP);
}
boolean askedForStop(int processNumber) {
return readByte(processNumber, STOP_BYTE_OFFSET) == STOP;
}
void askForRestart(int processNumber) {
writeByte(processNumber, RESTART_BYTE_OFFSET, RESTART);
}
boolean askedForRestart(int processNumber) {
return readByte(processNumber, RESTART_BYTE_OFFSET) == RESTART;
}
void acknowledgeAskForRestart(int processNumber) {
writeByte(processNumber, RESTART_BYTE_OFFSET, EMPTY);
}
@Override
public void close() {
IOUtils.closeQuietly(sharedMemory);
}
public void checkProcessNumber(int processNumber) {
if (processNumber < 0 || processNumber >= MAX_PROCESSES) {
throw new IllegalArgumentException(format("Process number %s is not valid", processNumber));
}
}
private void cleanData(int processNumber) {
for (int i = 0; i < BYTE_LENGTH_FOR_ONE_PROCESS; i++) {
writeByte(processNumber, i, EMPTY);
}
}
private void writeByte(int processNumber, int offset, byte value) {
mappedByteBuffer.put(offset(processNumber) + offset, value);
}
private void writeBytes(int processNumber, int offset, byte[] value) {
int bufferOffset = offset(processNumber) + offset;
for (int i = 0; i < value.length; i++) {
mappedByteBuffer.put(bufferOffset + i, value[i]);
}
}
private byte readByte(int processNumber, int offset) {
return mappedByteBuffer.get(offset(processNumber) + offset);
}
private byte[] readBytes(int processNumber, int offset, int length) {
int bufferOffset = offset(processNumber) + offset;
byte[] bytes = new byte[length];
for (int i = 0; i < length; i++) {
bytes[i] = mappedByteBuffer.get(bufferOffset + i);
}
return bytes;
}
private void writeLong(int processNumber, int offset, long value) {
mappedByteBuffer.putLong(offset(processNumber) + offset, value);
}
private long readLong(int processNumber, int offset) {
return mappedByteBuffer.getLong(offset(processNumber) + offset);
}
// VisibleForTesting
int offset(int processNumber) {
return BYTE_LENGTH_FOR_ONE_PROCESS * processNumber;
}
private class ProcessCommandsImpl implements ProcessCommands {
private final int processNumber;
public ProcessCommandsImpl(int processNumber) {
this.processNumber = processNumber;
}
@Override
public boolean isUp() {
return AllProcessesCommands.this.isUp(processNumber);
}
@Override
public void setUp() {
AllProcessesCommands.this.setUp(processNumber);
}
@Override
public boolean isOperational() {
return AllProcessesCommands.this.isOperational(processNumber);
}
@Override
public void setOperational() {
AllProcessesCommands.this.setOperational(processNumber);
}
@Override
public void ping() {
AllProcessesCommands.this.ping(processNumber);
}
@Override
public long getLastPing() {
return AllProcessesCommands.this.getLastPing(processNumber);
}
@Override
public void setHttpUrl(String s) {
AllProcessesCommands.this.setSystemInfoUrl(processNumber, s);
}
@Override
public String getHttpUrl() {
return AllProcessesCommands.this.getSystemInfoUrl(processNumber);
}
@Override
public void askForStop() {
AllProcessesCommands.this.askForStop(processNumber);
}
@Override
public boolean askedForStop() {
return AllProcessesCommands.this.askedForStop(processNumber);
}
@Override
public void askForRestart() {
AllProcessesCommands.this.askForRestart(processNumber);
}
@Override
public boolean askedForRestart() {
return AllProcessesCommands.this.askedForRestart(processNumber);
}
@Override
public void acknowledgeAskForRestart() {
AllProcessesCommands.this.acknowledgeAskForRestart(processNumber);
}
@Override
public void endWatch() {
throw new UnsupportedOperationException("ProcessCommands created from AllProcessesCommands can not be closed directly. Close AllProcessesCommands instead");
}
@Override
public void close() {
endWatch();
}
}
}