Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

libraries-2/src/main/java/com/baeldung/crawler4j/CrawlerStatistics.java

@@ -0,0 +1,22 @@
+package com.baeldung.crawler4j;
+
+public class CrawlerStatistics {
+    private int processedPageCount = 0;
+    private int totalLinksCount = 0;
+    
+    public void incrementProcessedPageCount() {
+        processedPageCount++;
+    }
+    
+    public void incrementTotalLinksCount(int linksCount) {
+        totalLinksCount += linksCount;
+    }
+    
+    public int getProcessedPageCount() {
+        return processedPageCount;
+    }
+    
+    public int getTotalLinksCount() {
+        return totalLinksCount;
+    }
+}

libraries-2/src/main/java/com/baeldung/crawler4j/HtmlCrawler.java

@@ -0,0 +1,48 @@
+package com.baeldung.crawler4j;
+
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import edu.uci.ics.crawler4j.crawler.Page;
+import edu.uci.ics.crawler4j.crawler.WebCrawler;
+import edu.uci.ics.crawler4j.parser.HtmlParseData;
+import edu.uci.ics.crawler4j.url.WebURL;
+
+public class HtmlCrawler extends WebCrawler {
+
+    private final static Pattern EXCLUSIONS = Pattern.compile(".*(\\.(css|js|xml|gif|jpg|png|mp3|mp4|zip|gz|pdf))$");
+    
+    private CrawlerStatistics stats;
+    
+    public HtmlCrawler(CrawlerStatistics stats) {
+        this.stats = stats;
+    }
+
+    @Override
+    public boolean shouldVisit(Page referringPage, WebURL url) {
+        String urlString = url.getURL().toLowerCase();
+        return !EXCLUSIONS.matcher(urlString).matches() 
+            && urlString.startsWith("https://www.baeldung.com/");
+    }
+
+    @Override
+    public void visit(Page page) {
+        String url = page.getWebURL().getURL();
+        stats.incrementProcessedPageCount();
+
+        if (page.getParseData() instanceof HtmlParseData) {
+            HtmlParseData htmlParseData = (HtmlParseData) page.getParseData();
+            String title = htmlParseData.getTitle();
+            String text = htmlParseData.getText();
+            String html = htmlParseData.getHtml();
+            Set<WebURL> links = htmlParseData.getOutgoingUrls();
+            stats.incrementTotalLinksCount(links.size());
+
+            System.out.printf("Page with title '%s' %n", title);
+            System.out.printf("    Text length: %d %n", text.length());
+            System.out.printf("    HTML length: %d %n", html.length());
+            System.out.printf("    %d outbound links %n", links.size());
+        }
+    }
+
+}

libraries-2/src/main/java/com/baeldung/crawler4j/HtmlCrawlerController.java

@@ -0,0 +1,36 @@
+package com.baeldung.crawler4j;
+
+import java.io.File;
+
+import edu.uci.ics.crawler4j.crawler.CrawlConfig;
+import edu.uci.ics.crawler4j.crawler.CrawlController;
+import edu.uci.ics.crawler4j.fetcher.PageFetcher;
+import edu.uci.ics.crawler4j.robotstxt.RobotstxtConfig;
+import edu.uci.ics.crawler4j.robotstxt.RobotstxtServer;
+
+public class HtmlCrawlerController {
+
+    public static void main(String[] args) throws Exception {
+        File crawlStorage = new File("src/test/resources/crawler4j");
+        CrawlConfig config = new CrawlConfig();
+        config.setCrawlStorageFolder(crawlStorage.getAbsolutePath());
+        config.setMaxDepthOfCrawling(2);
+
+        int numCrawlers = 12;
+
+        PageFetcher pageFetcher = new PageFetcher(config);
+        RobotstxtConfig robotstxtConfig = new RobotstxtConfig();
+        RobotstxtServer robotstxtServer = new RobotstxtServer(robotstxtConfig, pageFetcher);
+        CrawlController controller = new CrawlController(config, pageFetcher, robotstxtServer);
+
+        controller.addSeed("https://www.baeldung.com/");
+
+        CrawlerStatistics stats = new CrawlerStatistics();
+        CrawlController.WebCrawlerFactory<HtmlCrawler> factory = () -> new HtmlCrawler(stats);
+
+        controller.start(factory, numCrawlers);
+        System.out.printf("Crawled %d pages %n", stats.getProcessedPageCount());
+        System.out.printf("Total Number of outbound links = %d %n", stats.getTotalLinksCount());
+    }
+
+}

libraries-2/src/main/java/com/baeldung/crawler4j/ImageCrawler.java

@@ -0,0 +1,49 @@
+package com.baeldung.crawler4j;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+import edu.uci.ics.crawler4j.crawler.Page;
+import edu.uci.ics.crawler4j.crawler.WebCrawler;
+import edu.uci.ics.crawler4j.parser.BinaryParseData;
+import edu.uci.ics.crawler4j.url.WebURL;
+
+public class ImageCrawler extends WebCrawler {
+    private final static Pattern EXCLUSIONS = Pattern.compile(".*(\\.(css|js|xml|gif|png|mp3|mp4|zip|gz|pdf))$");
+
+    private static final Pattern IMG_PATTERNS = Pattern.compile(".*(\\.(jpg|jpeg))$");
+
+    private File saveDir;
+
+    public ImageCrawler(File saveDir) {
+        this.saveDir = saveDir;
+    }
+
+    @Override
+    public boolean shouldVisit(Page referringPage, WebURL url) {
+        String urlString = url.getURL().toLowerCase();
+        if (EXCLUSIONS.matcher(urlString).matches()) {
+            return false;
+        }
+
+        if (IMG_PATTERNS.matcher(urlString).matches() 
+            || urlString.startsWith("https://www.baeldung.com/")) {
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void visit(Page page) {
+        String url = page.getWebURL().getURL();
+        if (IMG_PATTERNS.matcher(url).matches() 
+            && page.getParseData() instanceof BinaryParseData) {
+            String extension = url.substring(url.lastIndexOf("."));
+            int contentLength = page.getContentData().length;
+
+            System.out.printf("Extension is '%s' with content length %d %n", extension, contentLength);
+        }
+    }
+
+}

libraries-2/src/main/java/com/baeldung/crawler4j/ImageCrawlerController.java

@@ -0,0 +1,36 @@
+package com.baeldung.crawler4j;
+
+import java.io.File;
+
+import edu.uci.ics.crawler4j.crawler.CrawlConfig;
+import edu.uci.ics.crawler4j.crawler.CrawlController;
+import edu.uci.ics.crawler4j.fetcher.PageFetcher;
+import edu.uci.ics.crawler4j.robotstxt.RobotstxtConfig;
+import edu.uci.ics.crawler4j.robotstxt.RobotstxtServer;
+
+public class ImageCrawlerController {
+
+    public static void main(String[] args) throws Exception {
+        File crawlStorage = new File("src/test/resources/crawler4j");
+        CrawlConfig config = new CrawlConfig();
+        config.setCrawlStorageFolder(crawlStorage.getAbsolutePath());
+        config.setIncludeBinaryContentInCrawling(true);
+        config.setMaxPagesToFetch(500);
+        
+        File saveDir = new File("src/test/resources/crawler4j");
+        
+        int numCrawlers = 12;
+        
+        PageFetcher pageFetcher = new PageFetcher(config);
+        RobotstxtConfig robotstxtConfig = new RobotstxtConfig();
+        RobotstxtServer robotstxtServer = new RobotstxtServer(robotstxtConfig, pageFetcher);
+        CrawlController controller = new CrawlController(config, pageFetcher, robotstxtServer);
+        
+        controller.addSeed("https://www.baeldung.com/");
+        
+        CrawlController.WebCrawlerFactory<ImageCrawler> factory = () -> new ImageCrawler(saveDir);
+        
+        controller.start(factory, numCrawlers);
+    }
+
+}

libraries-2/src/main/java/com/baeldung/crawler4j/MultipleCrawlerController.java

@@ -0,0 +1,54 @@
+package com.baeldung.crawler4j;
+
+import java.io.File;
+
+import edu.uci.ics.crawler4j.crawler.CrawlConfig;
+import edu.uci.ics.crawler4j.crawler.CrawlController;
+import edu.uci.ics.crawler4j.fetcher.PageFetcher;
+import edu.uci.ics.crawler4j.robotstxt.RobotstxtConfig;
+import edu.uci.ics.crawler4j.robotstxt.RobotstxtServer;
+
+public class MultipleCrawlerController {
+    public static void main(String[] args) throws Exception {
+        File crawlStorageBase = new File("src/test/resources/crawler4j");
+        CrawlConfig htmlConfig = new CrawlConfig();
+        CrawlConfig imageConfig = new CrawlConfig();
+        
+        htmlConfig.setCrawlStorageFolder(new File(crawlStorageBase, "html").getAbsolutePath());
+        imageConfig.setCrawlStorageFolder(new File(crawlStorageBase, "image").getAbsolutePath());
+        imageConfig.setIncludeBinaryContentInCrawling(true);
+        
+        htmlConfig.setMaxPagesToFetch(500);
+        imageConfig.setMaxPagesToFetch(1000);
+        
+        PageFetcher pageFetcherHtml = new PageFetcher(htmlConfig);
+        PageFetcher pageFetcherImage = new PageFetcher(imageConfig);
+        
+        RobotstxtConfig robotstxtConfig = new RobotstxtConfig();
+        RobotstxtServer robotstxtServer = new RobotstxtServer(robotstxtConfig, pageFetcherHtml);
+
+        CrawlController htmlController = new CrawlController(htmlConfig, pageFetcherHtml, robotstxtServer);
+        CrawlController imageController = new CrawlController(imageConfig, pageFetcherImage, robotstxtServer);
+        
+        htmlController.addSeed("https://www.baeldung.com/");
+        imageController.addSeed("https://www.baeldung.com/");
+        
+        CrawlerStatistics stats = new CrawlerStatistics();
+        CrawlController.WebCrawlerFactory<HtmlCrawler> htmlFactory = () -> new HtmlCrawler(stats);
+        
+        File saveDir = new File("src/test/resources/crawler4j");
+        CrawlController.WebCrawlerFactory<ImageCrawler> imageFactory = () -> new ImageCrawler(saveDir);
+        
+        imageController.startNonBlocking(imageFactory, 7);
+        htmlController.startNonBlocking(htmlFactory, 10);
+        
+
+        htmlController.waitUntilFinish();
+        System.out.printf("Crawled %d pages %n", stats.getProcessedPageCount());
+        System.out.printf("Total Number of outbound links = %d %n", stats.getTotalLinksCount());
+
+        imageController.waitUntilFinish();
+        System.out.printf("Image Crawler is finished.");
+        
+    }
+}

libraries-2/src/main/java/com/baeldung/jasperreports/Main.java

@@ -0,0 +1,40 @@
+package com.baeldung.jasperreports;
+
+import com.baeldung.jasperreports.config.JasperRerportsSimpleConfig;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Main {
+    public static void main(String[] args) {
+
+        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+        ctx.register(JasperRerportsSimpleConfig.class);
+        ctx.refresh();
+
+        SimpleReportFiller simpleReportFiller = ctx.getBean(SimpleReportFiller.class);
+        simpleReportFiller.setReportFileName("employeeEmailReport.jrxml");
+        simpleReportFiller.compileReport();
+
+        simpleReportFiller.setReportFileName("employeeReport.jrxml");
+        simpleReportFiller.compileReport();
+
+        Map<String, Object> parameters = new HashMap<>();
+        parameters.put("title", "Employee Report Example");
+        parameters.put("minSalary", 15000.0);
+        parameters.put("condition", " LAST_NAME ='Smith' ORDER BY FIRST_NAME");
+
+        simpleReportFiller.setParameters(parameters);
+        simpleReportFiller.fillReport();
+
+        SimpleReportExporter simpleExporter = ctx.getBean(SimpleReportExporter.class);
+        simpleExporter.setJasperPrint(simpleReportFiller.getJasperPrint());
+
+        simpleExporter.exportToPdf("employeeReport.pdf", "baeldung");
+        simpleExporter.exportToXlsx("employeeReport.xlsx", "Employee Data");
+        simpleExporter.exportToCsv("employeeReport.csv");
+        simpleExporter.exportToHtml("employeeReport.html");
+
+    }
+}

libraries-2/src/main/java/com/baeldung/jasperreports/SimpleReportExporter.java

@@ -0,0 +1,104 @@
+package com.baeldung.jasperreports;
+
+import net.sf.jasperreports.engine.JRException;
+import net.sf.jasperreports.engine.JasperPrint;
+import net.sf.jasperreports.engine.export.HtmlExporter;
+import net.sf.jasperreports.engine.export.JRCsvExporter;
+import net.sf.jasperreports.engine.export.JRPdfExporter;
+import net.sf.jasperreports.engine.export.ooxml.JRXlsxExporter;
+import net.sf.jasperreports.export.*;
+import org.springframework.stereotype.Component;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+@Component
+public class SimpleReportExporter {
+
+    private JasperPrint jasperPrint;
+
+    public SimpleReportExporter() {
+    }
+
+    public SimpleReportExporter(JasperPrint jasperPrint) {
+        this.jasperPrint = jasperPrint;
+    }
+
+    public JasperPrint getJasperPrint() {
+        return jasperPrint;
+    }
+
+    public void setJasperPrint(JasperPrint jasperPrint) {
+        this.jasperPrint = jasperPrint;
+    }
+
+    public void exportToPdf(String fileName, String author) {
+
+        // print report to file
+        JRPdfExporter exporter = new JRPdfExporter();
+
+        exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
+        exporter.setExporterOutput(new SimpleOutputStreamExporterOutput(fileName));
+
+        SimplePdfReportConfiguration reportConfig = new SimplePdfReportConfiguration();
+        reportConfig.setSizePageToContent(true);
+        reportConfig.setForceLineBreakPolicy(false);
+
+        SimplePdfExporterConfiguration exportConfig = new SimplePdfExporterConfiguration();
+        exportConfig.setMetadataAuthor(author);
+        exportConfig.setEncrypted(true);
+        exportConfig.setAllowedPermissionsHint("PRINTING");
+
+        exporter.setConfiguration(reportConfig);
+        exporter.setConfiguration(exportConfig);
+        try {
+            exporter.exportReport();
+        } catch (JRException ex) {
+            Logger.getLogger(SimpleReportFiller.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    public void exportToXlsx(String fileName, String sheetName) {
+        JRXlsxExporter exporter = new JRXlsxExporter();
+
+        exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
+        exporter.setExporterOutput(new SimpleOutputStreamExporterOutput(fileName));
+
+        SimpleXlsxReportConfiguration reportConfig = new SimpleXlsxReportConfiguration();
+        reportConfig.setSheetNames(new String[] { sheetName });
+
+        exporter.setConfiguration(reportConfig);
+
+        try {
+            exporter.exportReport();
+        } catch (JRException ex) {
+            Logger.getLogger(SimpleReportFiller.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    public void exportToCsv(String fileName) {
+        JRCsvExporter exporter = new JRCsvExporter();
+
+        exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
+        exporter.setExporterOutput(new SimpleWriterExporterOutput(fileName));
+
+        try {
+            exporter.exportReport();
+        } catch (JRException ex) {
+            Logger.getLogger(SimpleReportFiller.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    public void exportToHtml(String fileName) {
+        HtmlExporter exporter = new HtmlExporter();
+
+        exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
+        exporter.setExporterOutput(new SimpleHtmlExporterOutput(fileName));
+
+        try {
+            exporter.exportReport();
+        } catch (JRException ex) {
+            Logger.getLogger(SimpleReportFiller.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+}

libraries-2/src/main/java/com/baeldung/jasperreports/SimpleReportFiller.java

@@ -0,0 +1,85 @@
+package com.baeldung.jasperreports;
+
+import net.sf.jasperreports.engine.*;
+import net.sf.jasperreports.engine.util.JRSaver;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import javax.sql.DataSource;
+import java.io.InputStream;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+@Component
+public class SimpleReportFiller {
+
+    private String reportFileName;
+
+    private JasperReport jasperReport;
+
+    private JasperPrint jasperPrint;
+
+    @Autowired
+    private DataSource dataSource;
+
+    private Map<String, Object> parameters;
+
+    public SimpleReportFiller() {
+        parameters = new HashMap<>();
+    }
+
+    public void prepareReport() {
+        compileReport();
+        fillReport();
+    }
+
+    public void compileReport() {
+        try {
+            InputStream reportStream = getClass().getResourceAsStream("/".concat(reportFileName));
+            jasperReport = JasperCompileManager.compileReport(reportStream);
+            JRSaver.saveObject(jasperReport, reportFileName.replace(".jrxml", ".jasper"));
+        } catch (JRException ex) {
+            Logger.getLogger(SimpleReportFiller.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    public void fillReport() {
+        try {
+            jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, dataSource.getConnection());
+        } catch (JRException | SQLException ex) {
+            Logger.getLogger(SimpleReportFiller.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    public DataSource getDataSource() {
+        return dataSource;
+    }
+
+    public void setDataSource(DataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    public Map<String, Object> getParameters() {
+        return parameters;
+    }
+
+    public void setParameters(Map<String, Object> parameters) {
+        this.parameters = parameters;
+    }
+
+    public String getReportFileName() {
+        return reportFileName;
+    }
+
+    public void setReportFileName(String reportFileName) {
+        this.reportFileName = reportFileName;
+    }
+
+    public JasperPrint getJasperPrint() {
+        return jasperPrint;
+    }
+
+}

libraries-2/src/main/java/com/baeldung/jasperreports/config/JasperRerportsSimpleConfig.java

@@ -0,0 +1,30 @@
+package com.baeldung.jasperreports.config;
+
+import com.baeldung.jasperreports.SimpleReportExporter;
+import com.baeldung.jasperreports.SimpleReportFiller;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
+
+import javax.sql.DataSource;
+
+@Configuration
+public class JasperRerportsSimpleConfig {
+
+    @Bean
+    public DataSource dataSource() {
+        return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.HSQL).addScript("classpath:employee-schema.sql").build();
+    }
+
+    @Bean
+    public SimpleReportFiller reportFiller() {
+        return new SimpleReportFiller();
+    }
+
+    @Bean
+    public SimpleReportExporter reportExporter() {
+        return new SimpleReportExporter();
+    }
+
+}

libraries-2/src/main/java/com/baeldung/jbpm/WorkflowProcessMain.java

@@ -0,0 +1,19 @@
+package com.baeldung.jbpm;
+
+import org.kie.api.runtime.manager.Context;
+import org.kie.internal.runtime.manager.context.EmptyContext;
+
+import com.baeldung.jbpm.engine.WorkflowEngine;
+import com.baeldung.jbpm.engine.WorkflowEngineImpl;
+
+public class WorkflowProcessMain {
+
+    public static void main(String[] args) {
+        WorkflowEngine workflowEngine = new WorkflowEngineImpl();
+        String processId = "com.baeldung.bpmn.helloworld";
+        String kbaseId = "kbase";
+        String persistenceUnit = "org.jbpm.persistence.jpa";
+        Context<String> initialContext = EmptyContext.get();
+        workflowEngine.runjBPMEngineForProcess(processId, initialContext, kbaseId, persistenceUnit);
+    }
+}

libraries-2/src/main/java/com/baeldung/jbpm/engine/WorkflowEngine.java

@@ -0,0 +1,10 @@
+package com.baeldung.jbpm.engine;
+
+import org.kie.api.runtime.manager.Context;
+import org.kie.api.runtime.process.ProcessInstance;
+
+public interface WorkflowEngine {
+   
+    public ProcessInstance runjBPMEngineForProcess(String processId, Context<String> initialContext, String kbaseId, String persistenceUnit);
+    
+}

libraries-2/src/main/java/com/baeldung/jbpm/engine/WorkflowEngineImpl.java

@@ -0,0 +1,66 @@
+package com.baeldung.jbpm.engine;
+
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+import org.jbpm.test.JBPMHelper;
+import org.kie.api.KieBase;
+import org.kie.api.KieServices;
+import org.kie.api.runtime.KieContainer;
+import org.kie.api.runtime.KieSession;
+import org.kie.api.runtime.manager.Context;
+import org.kie.api.runtime.manager.RuntimeEngine;
+import org.kie.api.runtime.manager.RuntimeEnvironment;
+import org.kie.api.runtime.manager.RuntimeEnvironmentBuilder;
+import org.kie.api.runtime.manager.RuntimeManager;
+import org.kie.api.runtime.manager.RuntimeManagerFactory;
+import org.kie.api.runtime.process.ProcessInstance;
+
+public class WorkflowEngineImpl implements WorkflowEngine {
+
+    @Override
+    public ProcessInstance runjBPMEngineForProcess(String processId, Context<String> initialContext, String kbaseId, String persistenceUnit) {
+        RuntimeManager manager = null;
+        RuntimeEngine engine = null;
+        ProcessInstance pInstance = null;
+        try {
+            KieBase kbase = getKieBase(kbaseId);
+            manager = createJBPMRuntimeManager(kbase, persistenceUnit);
+            engine = manager.getRuntimeEngine(initialContext);
+            pInstance = executeProcessInstance(processId, manager, initialContext, engine);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            if (manager != null && engine != null)
+                manager.disposeRuntimeEngine(engine);
+            System.exit(0);
+        }
+        return pInstance;
+    }
+
+    private ProcessInstance executeProcessInstance(String processId, RuntimeManager manager, Context<String> initialContext, RuntimeEngine engine) {
+        KieSession ksession = engine.getKieSession();
+        ProcessInstance pInstance = ksession.startProcess(processId);
+        return pInstance;
+    }
+
+    private KieBase getKieBase(String kbaseId) {
+        KieServices ks = KieServices.Factory.get();
+        KieContainer kContainer = ks.getKieClasspathContainer();
+        KieBase kbase = kContainer.getKieBase(kbaseId);
+        return kbase;
+    }
+
+    private RuntimeManager createJBPMRuntimeManager(KieBase kbase, String persistenceUnit) {
+        JBPMHelper.startH2Server();
+        JBPMHelper.setupDataSource();
+        EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit);
+        RuntimeEnvironmentBuilder runtimeEnvironmentBuilder = RuntimeEnvironmentBuilder.Factory.get()
+            .newDefaultBuilder();
+        RuntimeEnvironment runtimeEnvironment = runtimeEnvironmentBuilder.entityManagerFactory(emf)
+            .knowledgeBase(kbase)
+            .get();
+        return RuntimeManagerFactory.Factory.get()
+            .newSingletonRuntimeManager(runtimeEnvironment);
+    }
+}

libraries-2/src/main/java/com/baeldung/mesos/HelloWorldMain.java

@@ -0,0 +1,42 @@
+package com.baeldung.mesos;
+
+import com.baeldung.mesos.schedulers.HelloWorldScheduler;
+import org.apache.mesos.MesosSchedulerDriver;
+import org.apache.mesos.Protos;
+import org.apache.mesos.Protos.CommandInfo;
+import org.apache.mesos.Protos.ExecutorInfo;
+import org.apache.mesos.Protos.FrameworkInfo;
+
+public class HelloWorldMain {
+
+    public static void main(String[] args) {
+
+        String path = System.getProperty("user.dir")
+                + "/target/libraries2-1.0.0-SNAPSHOT.jar";
+
+        CommandInfo.URI uri = CommandInfo.URI.newBuilder().setValue(path).setExtract(false).build();
+
+        String helloWorldCommand = "java -cp libraries2-1.0.0-SNAPSHOT.jar com.baeldung.mesos.executors.HelloWorldExecutor";
+        CommandInfo commandInfoHelloWorld = CommandInfo.newBuilder().setValue(helloWorldCommand).addUris(uri)
+                .build();
+
+        ExecutorInfo executorHelloWorld = ExecutorInfo.newBuilder()
+                .setExecutorId(Protos.ExecutorID.newBuilder().setValue("HelloWorldExecutor"))
+                .setCommand(commandInfoHelloWorld).setName("Hello World (Java)").setSource("java").build();
+
+        FrameworkInfo.Builder frameworkBuilder = FrameworkInfo.newBuilder().setFailoverTimeout(120000)
+                .setUser("")
+                .setName("Hello World Framework (Java)");
+
+        frameworkBuilder.setPrincipal("test-framework-java");
+
+        MesosSchedulerDriver driver = new MesosSchedulerDriver(new HelloWorldScheduler(executorHelloWorld), frameworkBuilder.build(), args[0]);
+
+        int status = driver.run() == Protos.Status.DRIVER_STOPPED ? 0 : 1;
+
+        // Ensure that the driver process terminates.
+        driver.stop();
+
+        System.exit(status);
+    }
+}

libraries-2/src/main/java/com/baeldung/mesos/executors/HelloWorldExecutor.java

@@ -0,0 +1,59 @@
+package com.baeldung.mesos.executors;
+
+import org.apache.mesos.Executor;
+import org.apache.mesos.ExecutorDriver;
+import org.apache.mesos.MesosExecutorDriver;
+import org.apache.mesos.Protos;
+import org.apache.mesos.Protos.TaskInfo;
+
+public class HelloWorldExecutor implements Executor {
+    @Override
+    public void registered(ExecutorDriver driver, Protos.ExecutorInfo executorInfo, Protos.FrameworkInfo frameworkInfo, Protos.SlaveInfo slaveInfo) {
+    }
+
+    @Override
+    public void reregistered(ExecutorDriver driver, Protos.SlaveInfo slaveInfo) {
+    }
+
+    @Override
+    public void disconnected(ExecutorDriver driver) {
+    }
+
+    @Override
+    public void launchTask(ExecutorDriver driver, TaskInfo task) {
+
+        Protos.TaskStatus status = Protos.TaskStatus.newBuilder().setTaskId(task.getTaskId())
+                .setState(Protos.TaskState.TASK_RUNNING).build();
+        driver.sendStatusUpdate(status);
+
+        String myStatus = "Hello Framework";
+        driver.sendFrameworkMessage(myStatus.getBytes());
+
+        System.out.println("Hello World!!!");
+
+        status = Protos.TaskStatus.newBuilder().setTaskId(task.getTaskId())
+                .setState(Protos.TaskState.TASK_FINISHED).build();
+        driver.sendStatusUpdate(status);
+    }
+
+    @Override
+    public void killTask(ExecutorDriver driver, Protos.TaskID taskId) {
+    }
+
+    @Override
+    public void frameworkMessage(ExecutorDriver driver, byte[] data) {
+    }
+
+    @Override
+    public void shutdown(ExecutorDriver driver) {
+    }
+
+    @Override
+    public void error(ExecutorDriver driver, String message) {
+    }
+
+    public static void main(String[] args) {
+        MesosExecutorDriver driver = new MesosExecutorDriver(new HelloWorldExecutor());
+        System.exit(driver.run() == Protos.Status.DRIVER_STOPPED ? 0 : 1);
+    }
+}

libraries-2/src/main/java/com/baeldung/mesos/schedulers/HelloWorldScheduler.java

@@ -0,0 +1,100 @@
+package com.baeldung.mesos.schedulers;
+
+import com.google.protobuf.ByteString;
+import org.apache.mesos.Protos;
+import org.apache.mesos.Protos.ExecutorInfo;
+import org.apache.mesos.Protos.Offer;
+import org.apache.mesos.Protos.OfferID;
+import org.apache.mesos.Protos.TaskInfo;
+import org.apache.mesos.Scheduler;
+import org.apache.mesos.SchedulerDriver;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class HelloWorldScheduler implements Scheduler {
+
+    private int launchedTasks = 0;
+    private final ExecutorInfo helloWorldExecutor;
+
+    public HelloWorldScheduler(ExecutorInfo helloWorldExecutor) {
+        this.helloWorldExecutor = helloWorldExecutor;
+    }
+
+    @Override
+    public void registered(SchedulerDriver schedulerDriver, Protos.FrameworkID frameworkID, Protos.MasterInfo masterInfo) {
+
+    }
+
+    @Override
+    public void reregistered(SchedulerDriver schedulerDriver, Protos.MasterInfo masterInfo) {
+
+    }
+
+    @Override
+    public void resourceOffers(SchedulerDriver schedulerDriver, List<Offer> list) {
+
+        for (Offer offer : list) {
+            List<TaskInfo> tasks = new ArrayList<TaskInfo>();
+            Protos.TaskID taskId = Protos.TaskID.newBuilder().setValue(Integer.toString(launchedTasks++)).build();
+
+            System.out.println("Launching printHelloWorld " + taskId.getValue() + " Hello World Java");
+            TaskInfo printHelloWorld = TaskInfo
+                    .newBuilder()
+                    .setName("printHelloWorld " + taskId.getValue())
+                    .setTaskId(taskId)
+                    .setSlaveId(offer.getSlaveId())
+                    .addResources(
+                            Protos.Resource.newBuilder().setName("cpus").setType(Protos.Value.Type.SCALAR)
+                                    .setScalar(Protos.Value.Scalar.newBuilder().setValue(1)))
+                    .addResources(
+                            Protos.Resource.newBuilder().setName("mem").setType(Protos.Value.Type.SCALAR)
+                                    .setScalar(Protos.Value.Scalar.newBuilder().setValue(128)))
+                    .setExecutor(ExecutorInfo.newBuilder(helloWorldExecutor)).build();
+
+            List<OfferID> offerIDS = new ArrayList<>();
+            offerIDS.add(offer.getId());
+
+            tasks.add(printHelloWorld);
+
+            schedulerDriver.declineOffer(offer.getId());
+            schedulerDriver.launchTasks(offerIDS, tasks);
+        }
+
+    }
+
+    @Override
+    public void offerRescinded(SchedulerDriver schedulerDriver, OfferID offerID) {
+
+    }
+
+    @Override
+    public void statusUpdate(SchedulerDriver schedulerDriver, Protos.TaskStatus taskStatus) {
+
+    }
+
+    @Override
+    public void frameworkMessage(SchedulerDriver schedulerDriver, Protos.ExecutorID executorID, Protos.SlaveID slaveID, byte[] bytes) {
+
+    }
+
+    @Override
+    public void disconnected(SchedulerDriver schedulerDriver) {
+
+    }
+
+    @Override
+    public void slaveLost(SchedulerDriver schedulerDriver, Protos.SlaveID slaveID) {
+
+    }
+
+    @Override
+    public void executorLost(SchedulerDriver schedulerDriver, Protos.ExecutorID executorID, Protos.SlaveID slaveID, int i) {
+
+    }
+
+    @Override
+    public void error(SchedulerDriver schedulerDriver, String s) {
+
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/git/Application.java

@@ -0,0 +1,41 @@
+package com.baeldung.picocli.git;
+
+import com.baeldung.picocli.git.commands.programmative.GitCommand;
+import com.baeldung.picocli.git.commands.subcommands.GitAddCommand;
+import com.baeldung.picocli.git.commands.subcommands.GitCommitCommand;
+import com.baeldung.picocli.git.commands.subcommands.GitConfigCommand;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import picocli.CommandLine;
+
+@SpringBootApplication
+public class Application implements CommandLineRunner {
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+
+    private GitCommand gitCommand;
+    private GitAddCommand addCommand;
+    private GitCommitCommand commitCommand;
+    private GitConfigCommand configCommand;
+
+    @Autowired
+    public Application(GitCommand gitCommand, GitAddCommand addCommand, GitCommitCommand commitCommand, GitConfigCommand configCommand) {
+        this.gitCommand = gitCommand;
+        this.addCommand = addCommand;
+        this.commitCommand = commitCommand;
+        this.configCommand = configCommand;
+    }
+
+    @Override
+    public void run(String... args) {
+        CommandLine commandLine = new CommandLine(gitCommand);
+        commandLine.addSubcommand("add", addCommand);
+        commandLine.addSubcommand("commit", commitCommand);
+        commandLine.addSubcommand("config", configCommand);
+
+        commandLine.parseWithHandler(new CommandLine.RunLast(), args);
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/git/commands/declarative/GitCommand.java

@@ -0,0 +1,32 @@
+package com.baeldung.picocli.git.commands.declarative;
+
+import com.baeldung.picocli.git.model.ConfigElement;
+import com.baeldung.picocli.git.commands.subcommands.GitAddCommand;
+import com.baeldung.picocli.git.commands.subcommands.GitCommitCommand;
+import com.baeldung.picocli.git.commands.subcommands.GitConfigCommand;
+import picocli.CommandLine;
+
+import static picocli.CommandLine.*;
+import static picocli.CommandLine.Command;
+
+@Command(
+  name = "git",
+  subcommands = {
+    GitAddCommand.class,
+    GitCommitCommand.class,
+    GitConfigCommand.class
+  }
+)
+public class GitCommand implements Runnable {
+    public static void main(String[] args) {
+        CommandLine commandLine = new CommandLine(new GitCommand());
+        commandLine.registerConverter(ConfigElement.class, ConfigElement::from);
+
+        commandLine.parseWithHandler(new RunLast(), args);
+    }
+
+    @Override
+    public void run() {
+        System.out.println("The popular git command");
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/git/commands/methods/GitCommand.java

@@ -0,0 +1,27 @@
+package com.baeldung.picocli.git.commands.methods;
+
+import picocli.CommandLine;
+
+import static picocli.CommandLine.Command;
+
+@Command(name = "git")
+public class GitCommand implements Runnable {
+    public static void main(String[] args) {
+        CommandLine.run(new GitCommand(), args);
+    }
+
+    @Override
+    public void run() {
+        System.out.println("The popular git command");
+    }
+
+    @Command(name = "add")
+    public void addCommand() {
+        System.out.println("Adding some files to the staging area");
+    }
+
+    @Command(name = "commit")
+    public void commitCommand() {
+        System.out.println("Committing files in the staging area, how wonderful?");
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/git/commands/programmative/GitCommand.java

@@ -0,0 +1,26 @@
+package com.baeldung.picocli.git.commands.programmative;
+
+import com.baeldung.picocli.git.commands.subcommands.GitAddCommand;
+import com.baeldung.picocli.git.commands.subcommands.GitCommitCommand;
+import org.springframework.stereotype.Component;
+import picocli.CommandLine;
+
+import static picocli.CommandLine.Command;
+import static picocli.CommandLine.RunLast;
+
+@Command(name = "git")
+@Component
+public class GitCommand implements Runnable {
+    public static void main(String[] args) {
+        CommandLine commandLine = new CommandLine(new GitCommand());
+        commandLine.addSubcommand("add", new GitAddCommand());
+        commandLine.addSubcommand("commit", new GitCommitCommand());
+
+        commandLine.parseWithHandler(new RunLast(), args);
+    }
+
+    @Override
+    public void run() {
+        System.out.println("The popular git command");
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/git/commands/subcommands/GitAddCommand.java

@@ -0,0 +1,31 @@
+package com.baeldung.picocli.git.commands.subcommands;
+
+import org.springframework.stereotype.Component;
+
+import java.nio.file.Path;
+import java.util.List;
+
+import static picocli.CommandLine.*;
+
+@Command(
+  name = "add"
+)
+@Component
+public class GitAddCommand implements Runnable {
+    @Option(names = "-A")
+    private boolean allFiles;
+
+    @Parameters(index = "0..*")
+    private List<Path> files;
+
+    @Override
+    public void run() {
+        if (allFiles) {
+            System.out.println("Adding all files to the staging area");
+        }
+
+        if (files != null) {
+            files.forEach(path -> System.out.println("Adding " + path + " to the staging area"));
+        }
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/git/commands/subcommands/GitCommitCommand.java

@@ -0,0 +1,26 @@
+package com.baeldung.picocli.git.commands.subcommands;
+
+import org.springframework.stereotype.Component;
+
+import static picocli.CommandLine.Command;
+import static picocli.CommandLine.Option;
+
+@Command(
+  name = "commit"
+)
+@Component
+public class GitCommitCommand implements Runnable {
+    @Option(names = {"-m", "--message"}, required = true)
+    private String[] messages;
+
+    @Override
+    public void run() {
+        System.out.println("Committing files in the staging area, how wonderful?");
+        if (messages != null) {
+            System.out.println("The commit message is");
+            for (String message : messages) {
+                System.out.println(message);
+            }
+        }
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/git/commands/subcommands/GitConfigCommand.java

@@ -0,0 +1,24 @@
+package com.baeldung.picocli.git.commands.subcommands;
+
+import com.baeldung.picocli.git.model.ConfigElement;
+import org.springframework.stereotype.Component;
+
+import static picocli.CommandLine.Command;
+import static picocli.CommandLine.Parameters;
+
+@Command(
+  name = "config"
+)
+@Component
+public class GitConfigCommand implements Runnable {
+    @Parameters(index = "0")
+    private ConfigElement element;
+
+    @Parameters(index = "1")
+    private String value;
+
+    @Override
+    public void run() {
+        System.out.println("Setting " + element.value() + " to " + value);
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/git/model/ConfigElement.java

@@ -0,0 +1,25 @@
+package com.baeldung.picocli.git.model;
+
+import java.util.Arrays;
+
+public enum ConfigElement {
+    USERNAME("user.name"),
+    EMAIL("user.email");
+
+    private final String value;
+
+    ConfigElement(String value) {
+        this.value = value;
+    }
+
+    public String value() {
+        return value;
+    }
+
+    public static ConfigElement from(String value) {
+        return Arrays.stream(values())
+          .filter(element -> element.value.equals(value))
+          .findFirst()
+          .orElseThrow(() -> new IllegalArgumentException("The argument " + value + " doesn't match any ConfigElement"));
+    }
+}

libraries-2/src/main/java/com/baeldung/picocli/helloworld/HelloWorldCommand.java

@@ -0,0 +1,20 @@
+package com.baeldung.picocli.helloworld;
+
+import picocli.CommandLine;
+
+import static picocli.CommandLine.Command;
+
+@Command(
+  name = "hello",
+  description = "Says hello"
+)
+public class HelloWorldCommand implements Runnable {
+    public static void main(String[] args) {
+        CommandLine.run(new HelloWorldCommand(), args);
+    }
+
+    @Override
+    public void run() {
+        System.out.println("Hello World!");
+    }
+}