Example usage for java.util.concurrent Executors newSingleThreadScheduledExecutor

List of usage examples for java.util.concurrent Executors newSingleThreadScheduledExecutor

Introduction

In this page you can find the example usage for java.util.concurrent Executors newSingleThreadScheduledExecutor.

Prototype

public static ScheduledExecutorService newSingleThreadScheduledExecutor() 

Source Link

Document

Creates a single-threaded executor that can schedule commands to run after a given delay, or to execute periodically.

Usage

From source file:org.dc.file.search.ui.DashboardForm.java

private void btnSearchActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnSearchActionPerformed
    int hopCount = DEFAULT_SEARCH_HOPE_COUNT;
    int timeout = DEFAULT_SEARCH_TIMEOUT_SEC;

    if (advancedSearchEnabled) {
        try {/*from   www .j a va 2s. co m*/
            hopCount = Integer.parseInt(txtHopCount.getText());
            timeout = Integer.parseInt(txtTimeoutSec.getText());
        } catch (NumberFormatException e) {
            JOptionPane.showMessageDialog(this, "Default search options will be used",
                    "Invalid Search Options!", JOptionPane.ERROR_MESSAGE);
        }
    }

    Store store = Store.getInstance();
    String key = txtSearchKey.getText();
    Peer localPeer = store.getLocalPeer();
    SearchRequest searchRequest = new SearchRequest(Calendar.getInstance().getTimeInMillis(), key, hopCount,
            localPeer);
    store.setMySearchRequest(searchRequest);
    store.addSearchRequest(searchRequest);
    store.setSearchResults(new ArrayList<>());
    List<DFile> results = Store.getInstance().findInFiles(searchRequest.getSearchKey());
    if (!results.isEmpty()) {
        SearchResult searchResult = new SearchResult(key, localPeer, 0, results);
        store.addSearchResult(searchResult);
    }
    for (Map.Entry<String, Peer> entry : Store.getInstance().getPeerMap().entrySet()) {
        Peer peer = entry.getValue();
        MessageUtils.sendUDPMessage(peer.getIp(), peer.getPort(),
                MessageType.SER + " " + localPeer.getIp() + " " + localPeer.getPort() + " \"" + key + "\" 2");
    }
    Runnable resultTask = () -> {
        try {
            List<SearchResult> searchResults = Store.getInstance().getSearchResults();
            resultFiles = new HashMap<>();
            if (searchResults != null) {
                DefaultTableModel model = (DefaultTableModel) tblSearchResults.getModel();
                model.setRowCount(0);
                for (int i = 0; i < searchResults.size(); i++) {
                    Object[] data = new Object[MAX_COLS];
                    SearchResult searchResult = searchResults.get(i);
                    Peer peer = searchResult.getPeerWithResults();
                    data[0] = peer.getKey();
                    data[1] = searchResult.getHopCount();
                    for (DFile dFile : searchResult.getResults()) {
                        data[2] = dFile.getFileName();
                        data[3] = new StarRater(5, dFile.getTotalRating(), 0);
                        resultFiles.put(dFile.getFileName(), dFile);
                        model.addRow(data);
                    }
                }
                tblSearchResults.setModel(model);
                model.fireTableDataChanged();
            }
        } catch (Throwable t) {
            System.out.println(t.getMessage());
        } finally {
            btnSearch.setEnabled(true);
        }
    };
    initSearchResultsTable();
    initCommentResultsTable();
    btnSearch.setEnabled(false);
    tblSearchResults.setVisible(true);
    ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    scheduler.schedule(resultTask, timeout, TimeUnit.SECONDS);
    resetAndStartProgress(timeout);
}

From source file:com.bytelightning.opensource.pokerface.PokerFace.java

/**
 * If requested by the user, this method walks the script directory discovering, loading, compiling, and initialing an .js javascript files it finds in the specified directory or it's children.
 * @param baseScriptDirectory   The contents of this directory should be structured in the same layout as the url's we wish to interfere with.
 * @param watchScriptDirectory   If true, a watch will be placed on <code>baseScriptDirectory</code> and any javascript file modifications (cud) will be dynamically rebuilt and reflected in the running server. 
 * @return   True if all scripts were successfully loaded.
 *///from ww  w. j ava 2  s  .c  o m
protected boolean configureScripts(final List<Path> jsLibs, final HierarchicalConfiguration scriptConfig,
        final Path baseScriptDirectory, boolean watchScriptDirectory) {
    // Our unit test has verified that CompiledScripts can produce objects (endpoints) that can be executed from ANY thread (and even concurrently execute immutable methods).
    // However we have not validated that Nashorn can compile *and* recompile scripts from multiple threads.
    //TODO: Write unit test to see if we can use all available processors to compile discovered javascript files.
    ScriptCompilationExecutor = Executors.newSingleThreadScheduledExecutor();
    // This is done to make sure the engine is allocated in the same thread that will be doing the compiling.
    Callable<Boolean> compileScriptsTask = new Callable<Boolean>() {
        @Override
        public Boolean call() {
            Nashorn = new ScriptEngineManager().getEngineByName("nashorn");

            if (jsLibs != null)
                for (Path lib : jsLibs)
                    if (!loadScriptLibrary(lib))
                        return false;

            // Recursively discover javascript files, compile, load, and setup any that are found.
            EnumSet<FileVisitOption> opts = EnumSet.of(FileVisitOption.FOLLOW_LINKS);
            try {
                Files.walkFileTree(baseScriptDirectory, opts, Integer.MAX_VALUE, new SimpleFileVisitor<Path>() {
                    @Override
                    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                            throws IOException {
                        if (Files.isDirectory(dir) && dir.getFileName().toString().startsWith("#"))
                            return FileVisitResult.SKIP_SUBTREE;
                        return super.preVisitDirectory(dir, attrs);
                    }

                    @Override
                    public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) throws IOException {
                        if (Files.isRegularFile(path)) {
                            if (path.toString().toLowerCase().endsWith(".js")) {
                                MakeJavaScriptEndPointDescriptor(baseScriptDirectory, path, scriptConfig,
                                        new NewEndpointSetupCallback());
                            }
                        }
                        return FileVisitResult.CONTINUE;
                    }
                });
            } catch (IOException e) {
                Logger.error("Unable recursively load scripts", e);
                return false;
            }
            return true;
        }
    };
    // Walk the root directory recursively compiling all discovered javascript files (does not return until all endpoint files have been setup).
    try {
        if (!ScriptCompilationExecutor.submit(compileScriptsTask).get())
            return false;
    } catch (Throwable e) {
        Logger.error("Unable to compile scripts", e);
        return false;
    }
    if (watchScriptDirectory) {
        try {
            // Establish a watch on the root
            ScriptDirectoryWatcher.establishWatch(baseScriptDirectory, new DirectoryWatchEventListener() {
                // Internal Callable task to load, compile, and initialize a javascript file endpoint.
                final class CreateEndpointTask implements Callable<Void> {
                    public CreateEndpointTask(Path file, EndpointSetupCompleteCallback callback) {
                        this.file = file;
                        this.callback = callback;
                    }

                    private final Path file;
                    private final EndpointSetupCompleteCallback callback;

                    @Override
                    public Void call() {
                        MakeJavaScriptEndPointDescriptor(baseScriptDirectory, file, scriptConfig, callback);
                        return null;
                    }
                }

                // Internal Callable task that gives us the ability to schedule a delayed unload of a deleted or obsoleted endpoint.
                // By delaying for a period of time longer than twice the socket timeout, we can safely call the endpoint's teardown method.
                final class DecommisionEndpointTask implements Callable<Void> {
                    private DecommisionEndpointTask(ScriptObjectMirror endpoint) {
                        this.endpoint = endpoint;
                    }

                    private final ScriptObjectMirror endpoint;

                    @Override
                    public Void call() {
                        if (endpoint.hasMember("teardown"))
                            endpoint.callMember("teardown");
                        return null;
                    }
                }

                /**
                 * Called by the WatchService when the contents of the script directory have changed.
                 */
                @Override
                public void onWatchEvent(Path watchDir, final Path oldFile, final Path newFile,
                        FileChangeType change) {
                    if (change == FileChangeType.eRenamed) {
                        // If it was changed to something that does *not* end .js then it should no longer be considered an endpoint.
                        if (oldFile.toString().toLowerCase().endsWith(".js"))
                            if (!newFile.toString().toLowerCase().endsWith(".js"))
                                change = FileChangeType.eDeleted;
                    }
                    if (change == FileChangeType.eModified || change == FileChangeType.eRenamed) {
                        // Decommission the obsolete and load the update.
                        try {
                            assert newFile.toString().toLowerCase().endsWith(".js"); // Will be true because of the 'rename' check at the top of this method.
                            ScriptCompilationExecutor
                                    .submit(new CreateEndpointTask(newFile, new NewEndpointSetupCallback() {
                                        @Override
                                        public ScriptObjectMirror setupComplete(JavaScriptEndPoint endpoint) {
                                            ScriptObjectMirror old = super.setupComplete(endpoint);
                                            assert old != null;
                                            // Yeah, it's hincky, but it won't be in use this long after we remove it from the Map.
                                            ScriptCompilationExecutor.schedule(new DecommisionEndpointTask(old),
                                                    6, TimeUnit.MINUTES);
                                            return null;
                                        }
                                    }));
                        } catch (Throwable e) {
                            Logger.error("Unable to compile modified script found at "
                                    + newFile.toAbsolutePath().toString(), e);
                        }
                    } else if (change == FileChangeType.eCreated) {
                        // This is the easy one.  If a javascript file was created, load it.
                        if (newFile.toString().toLowerCase().endsWith(".js")) {
                            try {
                                ScriptCompilationExecutor.submit(
                                        new CreateEndpointTask(newFile, new NewEndpointSetupCallback()));
                            } catch (Throwable e) {
                                Logger.error("Unable to compile new script found at "
                                        + newFile.toAbsolutePath().toString(), e);
                            }
                        }
                    } else if (change == FileChangeType.eDeleted) {
                        // Endpoint should be decommisioned.
                        if (oldFile.toString().toLowerCase().endsWith(".js")) {
                            String uriKey = FileToUriKey(baseScriptDirectory, oldFile);
                            ScriptObjectMirror desc = scripts.remove(uriKey);
                            if (desc != null) {
                                // Yeah, it's hincky, but it won't be in use this long after we remove it from the Map.
                                ScriptCompilationExecutor.schedule(new DecommisionEndpointTask(desc), 6,
                                        TimeUnit.MINUTES);
                            }
                        }
                    }
                }
            });
        } catch (IOException e) {
            Logger.error("Unable to establish a real time watch on the script directory.", e);
        }
    } else // Not watching for changes, so we are done with the Executor.
        ScriptCompilationExecutor.shutdown();
    return true;
}

From source file:com.web.server.WebServer.java

/**
 * This is the start of the all the services in web server
 * @param args/*from   w ww .  j a v a2 s.  c  o  m*/
 * @throws IOException 
 * @throws SAXException 
 */
public static void main(String[] args) throws IOException, SAXException {

    Hashtable urlClassLoaderMap = new Hashtable();
    Hashtable executorServicesMap = new Hashtable();
    Hashtable ataMap = new Hashtable<String, ATAConfig>();
    Hashtable messagingClassMap = new Hashtable();
    ConcurrentHashMap servletMapping = new ConcurrentHashMap();
    DigesterLoader serverdigesterLoader = DigesterLoader.newLoader(new FromXmlRulesModule() {

        protected void loadRules() {
            // TODO Auto-generated method stub
            try {
                loadXMLRules(new InputSource(new FileInputStream("./config/serverconfig-rules.xml")));
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    });
    Digester serverdigester = serverdigesterLoader.newDigester();
    final ServerConfig serverconfig = (ServerConfig) serverdigester
            .parse(new InputSource(new FileInputStream("./config/serverconfig.xml")));
    DigesterLoader messagingdigesterLoader = DigesterLoader.newLoader(new FromXmlRulesModule() {

        protected void loadRules() {
            // TODO Auto-generated method stub
            try {
                loadXMLRules(new InputSource(new FileInputStream("./config/messagingconfig-rules.xml")));
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    });
    Digester messagingdigester = messagingdigesterLoader.newDigester();
    MessagingElem messagingconfig = (MessagingElem) messagingdigester
            .parse(new InputSource(new FileInputStream("./config/messaging.xml")));
    //System.out.println(messagingconfig);
    ////System.out.println(serverconfig.getDeploydirectory());
    PropertyConfigurator.configure("log4j.properties");
    /*MemcachedClient cache=new MemcachedClient(
        new InetSocketAddress("localhost", 1000));*/

    // Store a value (async) for one hour
    //c.set("someKey", 36, new String("arun"));
    // Retrieve a value.        
    System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "org.apache.naming.java.javaURLContextFactory");
    System.setProperty(Context.URL_PKG_PREFIXES, "org.apache.naming");
    ExecutorService executor = java.util.concurrent.Executors.newCachedThreadPool();

    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    ObjectName name = null;
    try {
        name = new ObjectName("com.web.server:type=WarDeployer");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    WarDeployer warDeployer = new WarDeployer(serverconfig.getDeploydirectory(), serverconfig.getFarmWarDir(),
            serverconfig.getClustergroup(), urlClassLoaderMap, executorServicesMap, messagingClassMap,
            servletMapping, messagingconfig, sessionObjects);
    warDeployer.setPriority(MIN_PRIORITY);
    try {
        mbs.registerMBean(warDeployer, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    //warDeployer.start();
    executor.execute(warDeployer);

    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

    serverSocketChannel.bind(new InetSocketAddress("0.0.0.0", Integer.parseInt(serverconfig.getPort())));

    serverSocketChannel.configureBlocking(false);

    final byte[] shutdownBt = new byte[50];
    WebServerRequestProcessor webserverRequestProcessor = new WebServer().new WebServerRequestProcessor(
            servletMapping, urlClassLoaderMap, serverSocketChannel, serverconfig.getDeploydirectory(),
            Integer.parseInt(serverconfig.getShutdownport()), 1);
    webserverRequestProcessor.setPriority(MIN_PRIORITY);
    try {
        name = new ObjectName("com.web.server:type=WebServerRequestProcessor");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(webserverRequestProcessor, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    //webserverRequestProcessor.start();
    executor.execute(webserverRequestProcessor);

    for (int i = 0; i < 10; i++) {
        WebServerRequestProcessor webserverRequestProcessor1 = new WebServer().new WebServerRequestProcessor(
                servletMapping, urlClassLoaderMap, serverSocketChannel, serverconfig.getDeploydirectory(),
                Integer.parseInt(serverconfig.getShutdownport()), 2);
        webserverRequestProcessor1.setPriority(MIN_PRIORITY);
        try {
            name = new ObjectName("com.web.server:type=WebServerRequestProcessor" + (i + 1));
        } catch (MalformedObjectNameException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        try {
            mbs.registerMBean(webserverRequestProcessor1, name);
        } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        executor.execute(webserverRequestProcessor1);
    }

    ServerSocketChannel serverSocketChannelServices = ServerSocketChannel.open();

    serverSocketChannelServices
            .bind(new InetSocketAddress("0.0.0.0", Integer.parseInt(serverconfig.getServicesport())));

    serverSocketChannelServices.configureBlocking(false);

    ExecutorServiceThread executorService = new ExecutorServiceThread(serverSocketChannelServices,
            executorServicesMap, Integer.parseInt(serverconfig.getShutdownport()), ataMap, urlClassLoaderMap,
            serverconfig.getDeploydirectory(), serverconfig.getServicesdirectory(),
            serverconfig.getEarservicesdirectory(), serverconfig.getNodesport());

    try {
        name = new ObjectName("com.web.services:type=ExecutorServiceThread");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(executorService, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    //executorService.start();
    executor.execute(executorService);

    for (int i = 0; i < 10; i++) {
        ExecutorServiceThread executorService1 = new ExecutorServiceThread(serverSocketChannelServices,
                executorServicesMap, Integer.parseInt(serverconfig.getShutdownport()), ataMap,
                urlClassLoaderMap, serverconfig.getDeploydirectory(), serverconfig.getServicesdirectory(),
                serverconfig.getEarservicesdirectory(), serverconfig.getNodesport());

        try {
            name = new ObjectName("com.web.services:type=ExecutorServiceThread" + (i + 1));
        } catch (MalformedObjectNameException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        try {
            mbs.registerMBean(executorService1, name);
        } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        executor.execute(executorService1);
    }

    WebServerHttpsRequestProcessor webserverHttpsRequestProcessor = new WebServer().new WebServerHttpsRequestProcessor(
            servletMapping, urlClassLoaderMap, Integer.parseInt(serverconfig.getHttpsport()),
            serverconfig.getDeploydirectory(), Integer.parseInt(serverconfig.getShutdownport()),
            serverconfig.getHttpscertificatepath(), serverconfig.getHttpscertificatepasscode(), 1);
    try {
        name = new ObjectName("com.web.server:type=WebServerHttpsRequestProcessor");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(webserverHttpsRequestProcessor, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    webserverHttpsRequestProcessor.setPriority(MAX_PRIORITY);
    //webserverRequestProcessor.start();
    executor.execute(webserverHttpsRequestProcessor);

    /* for(int i=0;i<2;i++){
        webserverHttpsRequestProcessor=new WebServer().new WebServerHttpsRequestProcessor(urlClassLoaderMap,Integer.parseInt(serverconfig.getHttpsport())+(i+1),serverconfig.getDeploydirectory(),Integer.parseInt(serverconfig.getShutdownport()),serverconfig.getHttpscertificatepath(),serverconfig.getHttpscertificatepasscode(),1);
              
      try {
    name = new ObjectName("com.web.server:type=WebServerHttpsRequestProcessor"+(i+1));
      } catch (MalformedObjectNameException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
      } 
              
      try {
    mbs.registerMBean(webserverHttpsRequestProcessor, name);
      } catch (InstanceAlreadyExistsException | MBeanRegistrationException
       | NotCompliantMBeanException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
      }
              
      executor.execute(webserverHttpsRequestProcessor);
    }*/

    /*ATAServer ataServer=new ATAServer(serverconfig.getAtaaddress(),serverconfig.getAtaport(),ataMap);
            
    try {
       name = new ObjectName("com.web.services:type=ATAServer");
    } catch (MalformedObjectNameException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    } 
            
    try {
       mbs.registerMBean(ataServer, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException
    | NotCompliantMBeanException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    }
            
            
    ataServer.start();*/

    /*ATAConfigClient ataClient=new ATAConfigClient(serverconfig.getAtaaddress(),serverconfig.getAtaport(),serverconfig.getServicesport(),executorServicesMap);
            
    try {
       name = new ObjectName("com.web.services:type=ATAConfigClient");
    } catch (MalformedObjectNameException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    } 
            
    try {
       mbs.registerMBean(ataClient, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException
    | NotCompliantMBeanException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    }
    ataClient.start();*/

    MessagingServer messageServer = new MessagingServer(serverconfig.getMessageport(), messagingClassMap);

    try {
        name = new ObjectName("com.web.messaging:type=MessagingServer");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(messageServer, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    //messageServer.start();
    executor.execute(messageServer);

    RandomQueueMessagePicker randomqueuemessagepicker = new RandomQueueMessagePicker(messagingClassMap);

    try {
        name = new ObjectName("com.web.messaging:type=RandomQueueMessagePicker");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(randomqueuemessagepicker, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    //randomqueuemessagepicker.start();
    executor.execute(randomqueuemessagepicker);

    RoundRobinQueueMessagePicker roundrobinqueuemessagepicker = new RoundRobinQueueMessagePicker(
            messagingClassMap);

    try {
        name = new ObjectName("com.web.messaging:type=RoundRobinQueueMessagePicker");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(roundrobinqueuemessagepicker, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    //roundrobinqueuemessagepicker.start();
    executor.execute(roundrobinqueuemessagepicker);

    TopicMessagePicker topicpicker = new TopicMessagePicker(messagingClassMap);

    try {
        name = new ObjectName("com.web.messaging:type=TopicMessagePicker");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(topicpicker, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    //topicpicker.start();
    executor.execute(topicpicker);

    try {
        name = new ObjectName("com.web.server:type=SARDeployer");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    SARDeployer sarDeployer = SARDeployer.newInstance(serverconfig.getDeploydirectory());
    try {
        mbs.registerMBean(sarDeployer, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    executor.execute(sarDeployer);
    /*try {
       mbs.invoke(name, "startDeployer", null, null);
    } catch (InstanceNotFoundException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    } catch (ReflectionException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    } catch (MBeanException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    }
    */
    System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
    System.setProperty(Context.PROVIDER_URL, "rmi://localhost:" + serverconfig.getServicesregistryport());
    ;
    Registry registry = LocateRegistry.createRegistry(Integer.parseInt(serverconfig.getServicesregistryport()));

    /*JarDeployer jarDeployer=new JarDeployer(registry,serverconfig.getServicesdirectory(), serverconfig.getServiceslibdirectory(),serverconfig.getCachedir(),executorServicesMap, urlClassLoaderMap);
    try {
       name = new ObjectName("com.web.server:type=JarDeployer");
    } catch (MalformedObjectNameException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    } 
            
    try {
       mbs.registerMBean(jarDeployer, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException
    | NotCompliantMBeanException e1) {
       // TODO Auto-generated catch block
       e1.printStackTrace();
    }
            
    //jarDeployer.start();
    executor.execute(jarDeployer);*/

    EARDeployer earDeployer = new EARDeployer(registry, serverconfig.getEarservicesdirectory(),
            serverconfig.getDeploydirectory(), executorServicesMap, urlClassLoaderMap,
            serverconfig.getCachedir(), warDeployer);
    try {
        name = new ObjectName("com.web.server:type=EARDeployer");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(earDeployer, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    //earDeployer.start();
    executor.execute(earDeployer);

    JVMConsole jvmConsole = new JVMConsole(Integer.parseInt(serverconfig.getJvmConsolePort()));

    try {
        name = new ObjectName("com.web.server:type=JVMConsole");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(jvmConsole, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    executor.execute(jvmConsole);

    ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
    XMLDeploymentScanner xmlDeploymentScanner = new XMLDeploymentScanner(serverconfig.getDeploydirectory(),
            serverconfig.getServiceslibdirectory());
    exec.scheduleAtFixedRate(xmlDeploymentScanner, 0, 1000, TimeUnit.MILLISECONDS);

    EmbeddedJMS embeddedJMS = null;
    try {
        embeddedJMS = new EmbeddedJMS();
        embeddedJMS.start();
    } catch (Exception ex) {
        // TODO Auto-generated catch block
        ex.printStackTrace();
    }

    EJBDeployer ejbDeployer = new EJBDeployer(serverconfig.getServicesdirectory(), registry,
            Integer.parseInt(serverconfig.getServicesregistryport()), embeddedJMS);
    try {
        name = new ObjectName("com.web.server:type=EJBDeployer");
    } catch (MalformedObjectNameException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    try {
        mbs.registerMBean(ejbDeployer, name);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    //jarDeployer.start();
    executor.execute(ejbDeployer);

    new Thread() {
        public void run() {
            try {
                ServerSocket serverSocket = new ServerSocket(Integer.parseInt(serverconfig.getShutdownport()));
                while (true) {
                    Socket sock = serverSocket.accept();
                    InputStream istream = sock.getInputStream();
                    istream.read(shutdownBt);
                    String shutdownStr = new String(shutdownBt);
                    String[] shutdownToken = shutdownStr.split("\r\n\r\n");
                    //System.out.println(shutdownStr);
                    if (shutdownToken[0].startsWith("shutdown WebServer")) {
                        synchronized (shutDownObject) {
                            shutDownObject.notifyAll();
                        }
                    }
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }.start();

    Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
        public void run() {
            System.out.println("IN shutdown Hook");
            synchronized (shutDownObject) {
                shutDownObject.notifyAll();
            }
        }
    }));
    try {
        synchronized (shutDownObject) {
            shutDownObject.wait();
        }
        executor.shutdownNow();
        serverSocketChannel.close();
        serverSocketChannelServices.close();
        embeddedJMS.stop();

    } catch (Exception e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    System.out.println("IN shutdown Hook1");
    /*try{
       Thread.sleep(10000);
    }
    catch(Exception ex){
               
    }*/

    //webserverRequestProcessor.stop();
    //webserverRequestProcessor1.stop();

    /*warDeployer.stop();
    executorService.stop();
    //ataServer.stop();
    //ataClient.stop();
    messageServer.stop();
    randomqueuemessagepicker.stop();
    roundrobinqueuemessagepicker.stop();
    topicpicker.stop();*/
    /*try {
       mbs.invoke(new ObjectName("com.web.server:type=SARDeployer"), "destroyDeployer", null, null);
    } catch (InstanceNotFoundException | MalformedObjectNameException
    | ReflectionException | MBeanException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
    }*/
    //earDeployer.stop();
    System.exit(0);
}

From source file:view.WorkspacePanel.java

private void startSmartcardSearchThread(final boolean clear) {
    //rightPanel.setVisible(false);
    exec = Executors.newSingleThreadScheduledExecutor();
    exec.scheduleAtFixedRate(new Runnable() {
        @Override//w  w  w .  ja  v a 2  s  . c o  m
        public void run() {
            if (!populateComboBox(clear)) {
                mainWindow.getLoadingDialog().dispose();
                exec.shutdown();
            }
        }
    }, 0, 1, TimeUnit.SECONDS);
    mainWindow.createLoadingWindow().showDialog(LoadingDialog.LoadingType.SMARTCARD_SEARCHING);
    if (!mainWindow.getLoadingDialog().isVisible()) {
        if (null != exec) {
            exec.shutdown();
        }
    }
}

From source file:org.apache.nifi.cluster.manager.impl.WebClusterManager.java

public WebClusterManager(final HttpRequestReplicator httpRequestReplicator,
        final HttpResponseMapper httpResponseMapper, final DataFlowManagementService dataFlowManagementService,
        final ClusterManagerProtocolSenderListener senderListener, final NiFiProperties properties,
        final StringEncryptor encryptor, final OptimisticLockingManager optimisticLockingManager) {

    if (httpRequestReplicator == null) {
        throw new IllegalArgumentException("HttpRequestReplicator may not be null.");
    } else if (httpResponseMapper == null) {
        throw new IllegalArgumentException("HttpResponseMapper may not be null.");
    } else if (dataFlowManagementService == null) {
        throw new IllegalArgumentException("DataFlowManagementService may not be null.");
    } else if (senderListener == null) {
        throw new IllegalArgumentException("ClusterManagerProtocolSenderListener may not be null.");
    } else if (properties == null) {
        throw new IllegalArgumentException("NiFiProperties may not be null.");
    }//from w  w  w .j  av a 2  s  .c o  m

    // Ensure that our encryptor/decryptor is properly initialized
    this.httpRequestReplicator = httpRequestReplicator;
    this.httpResponseMapper = httpResponseMapper;
    this.dataFlowManagementService = dataFlowManagementService;
    this.properties = properties;
    this.bulletinRepository = new VolatileBulletinRepository();
    this.instanceId = UUID.randomUUID().toString();
    this.senderListener = senderListener;
    this.encryptor = encryptor;
    this.optimisticLockingManager = optimisticLockingManager;
    senderListener.addHandler(this);
    senderListener.setBulletinRepository(bulletinRepository);

    final String snapshotFrequency = properties.getProperty(NiFiProperties.COMPONENT_STATUS_SNAPSHOT_FREQUENCY,
            NiFiProperties.DEFAULT_COMPONENT_STATUS_SNAPSHOT_FREQUENCY);
    long snapshotMillis;
    try {
        snapshotMillis = FormatUtils.getTimeDuration(snapshotFrequency, TimeUnit.MILLISECONDS);
    } catch (final Exception e) {
        snapshotMillis = FormatUtils.getTimeDuration(NiFiProperties.DEFAULT_COMPONENT_STATUS_SNAPSHOT_FREQUENCY,
                TimeUnit.MILLISECONDS);
    }
    componentStatusSnapshotMillis = snapshotMillis;

    Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(new Runnable() {
        @Override
        public void run() {
            readLock.lock();
            try {
                for (final Node node : nodes) {
                    if (Status.CONNECTED.equals(node.getStatus())) {
                        ComponentStatusRepository statusRepository = componentMetricsRepositoryMap
                                .get(node.getNodeId());
                        if (statusRepository == null) {
                            statusRepository = createComponentStatusRepository();
                            componentMetricsRepositoryMap.put(node.getNodeId(), statusRepository);
                        }

                        // ensure this node has a payload
                        if (node.getHeartbeat() != null && node.getHeartbeatPayload() != null) {
                            // if nothing has been captured or the current heartbeat is newer, capture it - comparing the heatbeat created timestamp
                            // is safe since its marked as XmlTransient so we're assured that its based off the same clock that created the last capture date
                            if (statusRepository.getLastCaptureDate() == null || node.getHeartbeat()
                                    .getCreatedTimestamp() > statusRepository.getLastCaptureDate().getTime()) {
                                statusRepository.capture(node.getHeartbeatPayload().getProcessGroupStatus());
                            }
                        }
                    }
                }
            } catch (final Throwable t) {
                logger.warn("Unable to capture component metrics from Node heartbeats: " + t);
                if (logger.isDebugEnabled()) {
                    logger.warn("", t);
                }
            } finally {
                readLock.unlock("capture component metrics from node heartbeats");
            }
        }
    }, componentStatusSnapshotMillis, componentStatusSnapshotMillis, TimeUnit.MILLISECONDS);

    remoteInputPort = properties.getRemoteInputPort();
    if (remoteInputPort == null) {
        remoteSiteListener = null;
        remoteCommsSecure = null;
    } else {
        // Register the ClusterManagerServerProtocol as the appropriate resource for site-to-site Server Protocol
        RemoteResourceManager.setServerProtocolImplementation(ClusterManagerServerProtocol.RESOURCE_NAME,
                ClusterManagerServerProtocol.class);
        remoteCommsSecure = properties.isSiteToSiteSecure();
        if (remoteCommsSecure) {
            final SSLContext sslContext = SslContextFactory.createSslContext(properties, false);

            if (sslContext == null) {
                throw new IllegalStateException(
                        "NiFi Configured to allow Secure Site-to-Site communications but the Keystore/Truststore properties are not configured");
            }

            remoteSiteListener = new SocketRemoteSiteListener(remoteInputPort.intValue(), sslContext, this);
        } else {
            remoteSiteListener = new SocketRemoteSiteListener(remoteInputPort.intValue(), null, this);
        }
    }

    reportingTaskEngine = new FlowEngine(8, "Reporting Task Thread");

    processScheduler = new StandardProcessScheduler(new Heartbeater() {
        @Override
        public void heartbeat() {
        }
    }, this, encryptor);

    // When we construct the scheduling agents, we can pass null for a lot of the arguments because we are only
    // going to be scheduling Reporting Tasks. Otherwise, it would not be okay.
    processScheduler.setSchedulingAgent(SchedulingStrategy.TIMER_DRIVEN,
            new TimerDrivenSchedulingAgent(null, reportingTaskEngine, null, encryptor));
    processScheduler.setSchedulingAgent(SchedulingStrategy.CRON_DRIVEN,
            new QuartzSchedulingAgent(null, reportingTaskEngine, null, encryptor));
    processScheduler.setMaxThreadCount(SchedulingStrategy.TIMER_DRIVEN, 10);
    processScheduler.setMaxThreadCount(SchedulingStrategy.CRON_DRIVEN, 10);

    controllerServiceProvider = new StandardControllerServiceProvider(processScheduler, bulletinRepository);
}

From source file:org.zeroturnaround.exec.ProcessExecutor.java

/**
 * Wait until the process stops, a timeout occurs and the caller thread gets interrupted.
 * In the latter cases the process gets destroyed as well.
 *//*from w  w w . j  a  v  a 2s.co m*/
private ProcessResult waitFor(WaitForProcess task) throws IOException, InterruptedException, TimeoutException {
    ProcessResult result;
    if (timeout == null) {
        // Use the current thread
        result = task.call();
    } else {
        // Fork another thread to invoke Process.waitFor()
        ExecutorService service = Executors.newSingleThreadScheduledExecutor();
        try {
            result = service.submit(task).get(timeout, timeoutUnit);
        } catch (ExecutionException e) {
            Throwable c = e.getCause();
            if (c instanceof IOException)
                throw (IOException) c;
            if (c instanceof InterruptedException)
                throw (InterruptedException) c;
            if (c instanceof InvalidExitValueException)
                throw (InvalidExitValueException) c;
            throw new IllegalStateException("Error occured while waiting for process to finish:", c);
        } catch (TimeoutException e) {
            log.debug("{} is running too long", task);
            throw e;
        } finally {
            // Interrupt the task if it's still running and release the ExecutorService's resources
            service.shutdownNow();
        }
    }
    return result;
}

From source file:io.pravega.client.stream.impl.ControllerImplTest.java

@Before
public void setup() throws IOException {

    // Setup test server generating different success and failure responses.
    testServerImpl = new ControllerServiceImplBase() {
        @Override//from   w ww .j av a 2 s .c o m
        public void createStream(StreamConfig request, StreamObserver<CreateStreamStatus> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver.onNext(
                        CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream2")) {
                responseObserver.onNext(
                        CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.FAILURE).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream3")) {
                responseObserver.onNext(CreateStreamStatus.newBuilder()
                        .setStatus(CreateStreamStatus.Status.SCOPE_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream4")) {
                responseObserver.onNext(CreateStreamStatus.newBuilder()
                        .setStatus(CreateStreamStatus.Status.STREAM_EXISTS).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream5")) {
                responseObserver.onNext(CreateStreamStatus.newBuilder()
                        .setStatus(CreateStreamStatus.Status.INVALID_STREAM_NAME).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("streamparallel")) {

                // Simulating delay in sending response.
                Exceptions.handleInterrupted(() -> Thread.sleep(500));
                responseObserver.onNext(
                        CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("streamdelayed")) {

                // Simulating delay in sending response. This is used for the keepalive test,
                // where response time > 30 seconds is required to simulate a failure.
                Exceptions.handleInterrupted(() -> Thread.sleep(40000));
                responseObserver.onNext(
                        CreateStreamStatus.newBuilder().setStatus(CreateStreamStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void updateStream(StreamConfig request, StreamObserver<UpdateStreamStatus> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver.onNext(
                        UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream2")) {
                responseObserver.onNext(
                        UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.FAILURE).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream3")) {
                responseObserver.onNext(UpdateStreamStatus.newBuilder()
                        .setStatus(UpdateStreamStatus.Status.SCOPE_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream4")) {
                responseObserver.onNext(UpdateStreamStatus.newBuilder()
                        .setStatus(UpdateStreamStatus.Status.STREAM_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream5")) {
                responseObserver.onNext(UpdateStreamStatus.newBuilder()
                        .setStatus(UpdateStreamStatus.Status.UNRECOGNIZED).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void sealStream(StreamInfo request, StreamObserver<UpdateStreamStatus> responseObserver) {
            if (request.getStream().equals("stream1")) {
                responseObserver.onNext(
                        UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getStream().equals("stream2")) {
                responseObserver.onNext(
                        UpdateStreamStatus.newBuilder().setStatus(UpdateStreamStatus.Status.FAILURE).build());
                responseObserver.onCompleted();
            } else if (request.getStream().equals("stream3")) {
                responseObserver.onNext(UpdateStreamStatus.newBuilder()
                        .setStatus(UpdateStreamStatus.Status.SCOPE_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else if (request.getStream().equals("stream4")) {
                responseObserver.onNext(UpdateStreamStatus.newBuilder()
                        .setStatus(UpdateStreamStatus.Status.STREAM_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void deleteStream(StreamInfo request, StreamObserver<DeleteStreamStatus> responseObserver) {
            if (request.getStream().equals("stream1")) {
                responseObserver.onNext(
                        DeleteStreamStatus.newBuilder().setStatus(DeleteStreamStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getStream().equals("stream2")) {
                responseObserver.onNext(
                        DeleteStreamStatus.newBuilder().setStatus(DeleteStreamStatus.Status.FAILURE).build());
                responseObserver.onCompleted();
            } else if (request.getStream().equals("stream3")) {
                responseObserver.onNext(DeleteStreamStatus.newBuilder()
                        .setStatus(DeleteStreamStatus.Status.STREAM_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else if (request.getStream().equals("stream4")) {
                responseObserver.onNext(DeleteStreamStatus.newBuilder()
                        .setStatus(DeleteStreamStatus.Status.STREAM_NOT_SEALED).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void getCurrentSegments(StreamInfo request, StreamObserver<SegmentRanges> responseObserver) {
            if (request.getStream().equals("stream1")) {
                responseObserver.onNext(SegmentRanges.newBuilder()
                        .addSegmentRanges(ModelHelper.createSegmentRange("scope1", "stream1", 6, 0.0, 0.4))
                        .addSegmentRanges(ModelHelper.createSegmentRange("scope1", "stream1", 7, 0.4, 1.0))
                        .build());
                responseObserver.onCompleted();
            } else if (request.getStream().equals("streamparallel")) {
                Exceptions.handleInterrupted(() -> Thread.sleep(500));
                responseObserver.onNext(SegmentRanges.newBuilder()
                        .addSegmentRanges(
                                ModelHelper.createSegmentRange("scope1", "streamparallel", 0, 0.0, 0.4))
                        .addSegmentRanges(
                                ModelHelper.createSegmentRange("scope1", "streamparallel", 1, 0.4, 1.0))
                        .build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void getSegments(GetSegmentsRequest request, StreamObserver<SegmentsAtTime> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                SegmentId segment1 = ModelHelper.createSegmentId("scope1", "stream1", 0);
                SegmentId segment2 = ModelHelper.createSegmentId("scope1", "stream1", 1);
                responseObserver.onNext(SegmentsAtTime.newBuilder()
                        .addSegments(SegmentLocation.newBuilder().setSegmentId(segment1).setOffset(10).build())
                        .addSegments(SegmentLocation.newBuilder().setSegmentId(segment2).setOffset(20).build())
                        .build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void getSegmentsImmediatlyFollowing(SegmentId request,
                StreamObserver<SuccessorResponse> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                Map<SegmentId, Pair<Double, Double>> result = new HashMap<>();
                if (request.getSegmentNumber() == 0) {
                    result.put(ModelHelper.createSegmentId("scope1", "stream1", 2), Pair.of(0.0, 0.25));
                    result.put(ModelHelper.createSegmentId("scope1", "stream1", 3), Pair.of(0.25, 0.5));
                } else if (request.getSegmentNumber() == 1) {
                    result.put(ModelHelper.createSegmentId("scope1", "stream1", 4), Pair.of(0.5, 0.75));
                    result.put(ModelHelper.createSegmentId("scope1", "stream1", 5), Pair.of(0.75, 1.0));
                } else if (request.getSegmentNumber() == 2 || request.getSegmentNumber() == 3) {
                    result.put(ModelHelper.createSegmentId("scope1", "stream1", 6), Pair.of(0.0, 0.5));
                } else if (request.getSegmentNumber() == 4 || request.getSegmentNumber() == 5) {
                    result.put(ModelHelper.createSegmentId("scope1", "stream1", 7), Pair.of(0.5, 0.25));
                }
                val builder = SuccessorResponse.newBuilder();
                for (Entry<SegmentId, Pair<Double, Double>> entry : result.entrySet()) {
                    builder.addSegments(SuccessorResponse.SegmentEntry.newBuilder()
                            .setSegment(Controller.SegmentRange.newBuilder().setSegmentId(entry.getKey())
                                    .setMinKey(entry.getValue().getLeft())
                                    .setMaxKey(entry.getValue().getRight()).build())
                            .addValue(10 * entry.getKey().getSegmentNumber()).build());
                }
                responseObserver.onNext(builder.build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void scale(ScaleRequest request, StreamObserver<ScaleResponse> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver
                        .onNext(ScaleResponse.newBuilder().setStatus(ScaleResponse.ScaleStreamStatus.STARTED)
                                .addSegments(ModelHelper.createSegmentRange("scope1", "stream1", 0, 0.0, 0.5))
                                .addSegments(ModelHelper.createSegmentRange("scope1", "stream1", 1, 0.5, 1.0))
                                .setEpoch(0).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void checkScale(ScaleStatusRequest request,
                StreamObserver<ScaleStatusResponse> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver.onNext(ScaleStatusResponse.newBuilder()
                        .setStatus(ScaleStatusResponse.ScaleStatus.SUCCESS).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void getURI(SegmentId request, StreamObserver<NodeUri> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver
                        .onNext(NodeUri.newBuilder().setEndpoint("localhost").setPort(SERVICE_PORT).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void isSegmentValid(SegmentId request,
                StreamObserver<SegmentValidityResponse> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver.onNext(SegmentValidityResponse.newBuilder().setResponse(true).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream2")) {
                responseObserver.onNext(SegmentValidityResponse.newBuilder().setResponse(false).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void createTransaction(CreateTxnRequest request,
                StreamObserver<Controller.CreateTxnResponse> responseObserver) {
            Controller.CreateTxnResponse.Builder builder = Controller.CreateTxnResponse.newBuilder();

            if (request.getStreamInfo().getStream().equals("stream1")) {
                builder.setTxnId(TxnId.newBuilder().setHighBits(11L).setLowBits(22L).build());
                builder.addActiveSegments(ModelHelper.createSegmentRange("scope1", "stream1", 0, 0.0, 0.5));
                builder.addActiveSegments(ModelHelper.createSegmentRange("scope1", "stream1", 1, 0.5, 1.0));
                responseObserver.onNext(builder.build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream2")) {
                builder.addActiveSegments(ModelHelper.createSegmentRange("scope1", "stream2", 0, 0.0, 1.0));
                builder.setTxnId(TxnId.newBuilder().setHighBits(33L).setLowBits(44L).build());
                responseObserver.onNext(builder.build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void commitTransaction(TxnRequest request,
                StreamObserver<Controller.TxnStatus> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver.onNext(Controller.TxnStatus.newBuilder()
                        .setStatus(Controller.TxnStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream2")) {
                responseObserver.onNext(Controller.TxnStatus.newBuilder()
                        .setStatus(Controller.TxnStatus.Status.FAILURE).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream3")) {
                responseObserver.onNext(Controller.TxnStatus.newBuilder()
                        .setStatus(Controller.TxnStatus.Status.STREAM_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream4")) {
                responseObserver.onNext(Controller.TxnStatus.newBuilder()
                        .setStatus(Controller.TxnStatus.Status.TRANSACTION_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void abortTransaction(TxnRequest request,
                StreamObserver<Controller.TxnStatus> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver.onNext(Controller.TxnStatus.newBuilder()
                        .setStatus(Controller.TxnStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream2")) {
                responseObserver.onNext(Controller.TxnStatus.newBuilder()
                        .setStatus(Controller.TxnStatus.Status.FAILURE).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream3")) {
                responseObserver.onNext(Controller.TxnStatus.newBuilder()
                        .setStatus(Controller.TxnStatus.Status.STREAM_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream4")) {
                responseObserver.onNext(Controller.TxnStatus.newBuilder()
                        .setStatus(Controller.TxnStatus.Status.TRANSACTION_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void pingTransaction(PingTxnRequest request, StreamObserver<PingTxnStatus> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver.onNext(PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.OK).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void checkTransactionState(TxnRequest request, StreamObserver<TxnState> responseObserver) {
            if (request.getStreamInfo().getStream().equals("stream1")) {
                responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.OPEN).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream2")) {
                responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.UNKNOWN).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream3")) {
                responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.COMMITTING).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream4")) {
                responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.COMMITTED).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream5")) {
                responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.ABORTING).build());
                responseObserver.onCompleted();
            } else if (request.getStreamInfo().getStream().equals("stream6")) {
                responseObserver.onNext(TxnState.newBuilder().setState(TxnState.State.ABORTED).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void createScope(ScopeInfo request, StreamObserver<CreateScopeStatus> responseObserver) {
            if (request.getScope().equals("scope1")) {
                responseObserver.onNext(
                        CreateScopeStatus.newBuilder().setStatus(CreateScopeStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getScope().equals("scope2")) {
                responseObserver.onNext(
                        CreateScopeStatus.newBuilder().setStatus(CreateScopeStatus.Status.FAILURE).build());
                responseObserver.onCompleted();
            } else if (request.getScope().equals("scope3")) {
                responseObserver.onNext(CreateScopeStatus.newBuilder()
                        .setStatus(CreateScopeStatus.Status.INVALID_SCOPE_NAME).build());
                responseObserver.onCompleted();
            } else if (request.getScope().equals("scope4")) {
                responseObserver.onNext(CreateScopeStatus.newBuilder()
                        .setStatus(CreateScopeStatus.Status.SCOPE_EXISTS).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }

        @Override
        public void deleteScope(ScopeInfo request, StreamObserver<DeleteScopeStatus> responseObserver) {
            if (request.getScope().equals("scope1")) {
                responseObserver.onNext(
                        DeleteScopeStatus.newBuilder().setStatus(DeleteScopeStatus.Status.SUCCESS).build());
                responseObserver.onCompleted();
            } else if (request.getScope().equals("scope2")) {
                responseObserver.onNext(
                        DeleteScopeStatus.newBuilder().setStatus(DeleteScopeStatus.Status.FAILURE).build());
                responseObserver.onCompleted();
            } else if (request.getScope().equals("scope3")) {
                responseObserver.onNext(DeleteScopeStatus.newBuilder()
                        .setStatus(DeleteScopeStatus.Status.SCOPE_NOT_EMPTY).build());
                responseObserver.onCompleted();
            } else if (request.getScope().equals("scope4")) {
                responseObserver.onNext(DeleteScopeStatus.newBuilder()
                        .setStatus(DeleteScopeStatus.Status.SCOPE_NOT_FOUND).build());
                responseObserver.onCompleted();
            } else {
                responseObserver.onError(Status.INTERNAL.withDescription("Server error").asRuntimeException());
            }
        }
    };

    serverPort = TestUtils.getAvailableListenPort();
    testGRPCServer = NettyServerBuilder.forPort(serverPort).addService(testServerImpl).build().start();
    controllerClient = new ControllerImpl(URI.create("tcp://localhost:" + serverPort));
    executor = Executors.newSingleThreadScheduledExecutor();
}

From source file:org.onebusaway.siri.core.SiriCommon.java

/****
 * Protected Methods
 ****/

protected ScheduledExecutorService createExecutor() {
    return Executors.newSingleThreadScheduledExecutor();
}

From source file:github.popeen.dsub.fragments.NowPlayingFragment.java

private void onResumeHandlers() {
    executorService = Executors.newSingleThreadScheduledExecutor();
    setControlsVisible(true);/*from ww w .ja va  2s.c  o m*/

    final DownloadService downloadService = getDownloadService();
    if (downloadService == null || downloadService.getCurrentPlaying() == null || startFlipped) {
        playlistFlipper.setDisplayedChild(1);
        startFlipped = false;
    }
    if (downloadService != null && downloadService.getKeepScreenOn()) {
        context.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    } else {
        context.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    }

    updateButtons();

    if (currentPlaying == null && downloadService != null
            && currentPlaying == downloadService.getCurrentPlaying()) {
        getImageLoader().loadImage(albumArtImageView, (Entry) null, true, false);
    }

    context.runWhenServiceAvailable(new Runnable() {
        @Override
        public void run() {
            if (primaryFragment) {
                DownloadService downloadService = getDownloadService();
                downloadService.startRemoteScan();
                downloadService.addOnSongChangedListener(NowPlayingFragment.this, true);
            }
            updateRepeatButton();
            updateTitle();
        }
    });
}

From source file:com.app.services.ExecutorServiceThread.java

public void start() {
    schexc = Executors.newSingleThreadScheduledExecutor();
    schexc.execute(this);
    log.info("started");

}