aswi2020horky-gitlab/project/Deserializer/src/Converter.java @ 79e3d7d7

import java.io.File;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import jdeserialize.content;
import jdeserialize.jdeserialize;
import io.Database.DB_Messenger;
import io.Database;
import io.FileWorker;

/**
 * An instance of this class is a thread for converting an input file or SQL
 * query to the resulting JSON.
 */
public class Converter extends Thread {

	/**
	 * The user interface that this thread created.
	 */
	private IConversionResults ui;

	/**
	 * True, if thread is active, otherwise false. Thread-safe variable.
	 */
	private AtomicBoolean active;

	/**
	 * "Mutex" for the producer–consumer.
	 */
	private Lock entryLock;

	/**
	 * Semaphore for the existence of an input requirement (producer-consumer).
	 */
	private Semaphore inputAvailable;

	/**
	 * Variable for input file. Set by the user.
	 */
	private File inputFile;

	/**
	 * Variable for SQL query. Set by the user.
	 */
	private DB_Messenger query;

	/**
	 * Initializes instance attributes.
	 * 
	 * @param ui instance of the Window or CLI.
	 */
	public Converter(IConversionResults ui) {
		this.ui = ui;
		active = new AtomicBoolean(true);
		entryLock = new ReentrantLock();
		inputAvailable = new Semaphore(0);
	}

	/**
	 * End of the thread run.
	 */
	public void end() {
		active.set(false);
		setInput(null, null);
	}

	/**
	 * Sets the input processing request. One of the input parameters should be
	 * null.
	 * 
	 * @param inputFile input file.
	 * @param query     SQL query.
	 */
	public void setInput(File inputFile, DB_Messenger query) {
		entryLock.lock();
		this.inputFile = inputFile;
		this.query = query;
		entryLock.unlock();

		if (!inputAvailable.tryAcquire())
			inputAvailable.release(); // MAX VALUE = 1!
	}

	/**
	 * Get a request to process the input.
	 * 
	 * @param inputFile variable for input file "passing by reference".
	 * @param query     variable for SQL query "passing by reference".
	 * 
	 * @return true, when there is a request to process the input.
	 */
	public boolean getInput(AtomicReference<File> inputFile, AtomicReference<DB_Messenger> query) {
		try {
			inputAvailable.acquire();
		} catch (InterruptedException e) {
			return false;
		}

		entryLock.lock();
		inputFile.set(this.inputFile);
		query.set(this.query);

		this.inputFile = null;
		this.query = null;
		entryLock.unlock();

		return inputFile.get() != null || query.get() != null;
	}

	@Override
	public void run() {
		super.run();
		while (active.get()) {
			AtomicReference<File> inputFile = new AtomicReference<File>();
			AtomicReference<DB_Messenger> query = new AtomicReference<DB_Messenger>();

			// Get input data from the user.
			if (!getInput(inputFile, query)) {
				// If there is no data, continue.
				continue;
			}

			// Get the byte array from the input.
			byte array[];
			try {
				array = getBytes(inputFile.get(), query.get());
			} catch (Exception e) {
				// If an error occurs, it informs the user interface and continues.
				ui.loadingInputFileError();
				continue;
			}

			// Deserialization of read data.
			StringBuilder json = new StringBuilder();
			boolean error = false;
			try {
				// Redirection of System.out to jdeserialize log file
				System.setOut(FileWorker.createRedirectStream(false));
				System.setErr(FileWorker.createRedirectStream(true));
				System.out.println("--- jdeserialize begins ---".toUpperCase());
				convert(array, json);
			} catch (Exception e) {
				e.printStackTrace();
				error = true;
			} finally {
				System.out.println("--- jdeserialize ends ---".toUpperCase());
				System.out.flush();
				System.err.flush();
				System.setErr(new PrintStream(new FileOutputStream(FileDescriptor.err)));
				System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
			}

			// Pass the deserialization results to the UI.
			ui.completed(error ? null : json.toString(), array == null ? null : new String(array));
		}
	}

	/**
	 * Retrieve data from the file or database. One parameter should always be null.
	 * 
	 * @param file  input file.
	 * @param query input query.
	 * 
	 * @return read data in a byte array.
	 * @throws Exception if an error occurs while retrieving data.
	 */
	private byte[] getBytes(File file, DB_Messenger query) throws Exception {
		byte array[];
		if (file != null) {
			array = FileWorker.loadFileContent(file);
		} else {
			array = Database.getBlobBytes(query);
		}
		array = FileWorker.extractFileContent(array);
		return array;
	}

	/**
	 * Converts the input byte buffer given by parameter into json which is saved
	 * using the StringBuilder.
	 * 
	 * @param buffer byte array buffer for input data of serialized object.
	 * @param json   StringBuilder to which will be saved the json result.
	 * 
	 * @throws Exception if an error occurred during deserialization.
	 */
	private void convert(byte[] buffer, StringBuilder json) throws Exception {
		jdeserialize deserializer = new jdeserialize(buffer);

		// gets the "contents" into an array - returns the deserialization of all
		// 'writes' into serialized object via objectOutputStream
		List<content> cntnts = deserializer.getContent();

		for (content cnt : cntnts) {
			if (cnt != null) {
				json.append(cnt.toJson("", null, false)).append("\n");
			}
		}
	}

}