Starts the JDCP server.
8376
private static void startServer() {

    try {

      JdcpUtil.initialize();

      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      EmbeddedDataSource ds = new EmbeddedDataSource();
      ds.setConnectionAttributes("create=true");
      ds.setDatabaseName("classes");

      System.err.print("Initializing progress monitor...");
      ProgressPanel panel = new ProgressPanel();
      panel.setPreferredSize(new Dimension(500, 350));
      System.err.println("OK");

      System.err.print("Initializing folders...");
      Preferences pref = Preferences
          .userNodeForPackage(JobServer.class);
      String path = pref.get("rootDirectory", "./server");
      File rootDirectory = new File(path);
      File jobsDirectory = new File(rootDirectory, "jobs");

      rootDirectory.mkdir();
      jobsDirectory.mkdir();
      System.err.println("OK");

      System.err.print("Initializing service...");
      DbClassManager classManager = new DbClassManager(ds);
      classManager.prepareDataSource();

      TaskScheduler scheduler = new PrioritySerialTaskScheduler();
      Executor executor = Executors.newCachedThreadPool();
      JobServer jobServer = new JobServer(jobsDirectory, panel, scheduler, classManager, executor);
      AuthenticationServer authServer = new AuthenticationServer(jobServer, JdcpUtil.DEFAULT_PORT);
      System.err.println("OK");

      System.err.print("Exporting service stubs...");
//      JobService jobStub = (JobService) UnicastRemoteObject.exportObject(
//          jobServer, 0);
      System.err.println("OK");

      System.err.print("Binding service...");
      final Registry registry = LocateRegistry.createRegistry(JdcpUtil.DEFAULT_PORT);
      registry.bind("AuthenticationService", authServer);
      System.err.println("OK");

      System.err.println("Server ready");

      JFrame frame = new JFrame("JDCP Server");
      frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

      frame.getContentPane().add(panel);
      frame.pack();

      frame.addWindowListener(new WindowAdapter() {
        public void windowClosed(WindowEvent event) {
          System.err.print("Shutting down...");
          try {
            registry.unbind("AuthenticationService");
            System.err.println("OK");
          } catch (Exception e) {
            e.printStackTrace();
          }
          System.exit(0);
        }
      });

      frame.setVisible(true);

    } catch (Exception e) {

      System.err.println("Server exception:");
      e.printStackTrace();

    }

  }
626557
public synchronized void start() {

        String path = OpenCms.getSystemInfo().getAbsoluteRfsPathRelativeToWebInf("config/jlanConfig.xml");
        File configFile = new File(path);
        if (configFile.exists()) {

            if (m_thread == null) {
                m_thread = new JlanThread(path);
                m_thread.start();
            }
        } else {
            String message = "Not starting JLAN server because no config file was found at " + path;
            System.out.println(message);
            LOG.warn(message);
        }
    }
678778
public void start() {
		if (tryToStart()) {
			throw new IllegalStateException("The StreamServer is already started");
		}
		logger.debug("StreamServer starting {}:{}", serverSocket.getInetAddress(), serverSocket.getLocalPort());
		keepRunning.set(true);
		executor.submit(new Server());
	}
909642
public void start() {
        synchronized (LOCK) {
            if (!this.active) {
                this.active = true;
                logger.info("Starting UDP Manager");
                try {
                    generateTasks();
                    logger.info("Initialized UDP interface[" + inet + "]: bind address=" + bindAddress);
                } catch (IOException e) {
                    logger.error("An error occurred while initializing the polling tasks", e);
                    stop();
                }
            }
        }
    }
134771
public void start() {
		if (socket == null) {
			throw new RuntimeException("Cannot bind a server that has not been initialized!");
		}
		running = true;

		Thread t = new Thread(this);
		t.setName("HttpServer");
		t.start();
	}
701321
public void start() throws IOException{
       remote_sock.setSoTimeout(iddleTimeout);
       client_sock.setSoTimeout(iddleTimeout);

       log("Starting UDP relay server on "+relayIP+":"+relayPort);
       log("Remote socket "+remote_sock.getLocalAddress()+":"+
                            remote_sock.getLocalPort());

       pipe_thread1 = new Thread(this,"pipe1");
       pipe_thread2 = new Thread(this,"pipe2");

       lastReadTime = System.currentTimeMillis();

       pipe_thread1.start();
       pipe_thread2.start();
    }
1088417
public void start() throws Throwable
   {
      if (!running.get())
      {
         InetSocketAddress address = new InetSocketAddress(bindAddress, bindPort); 

         ss = new ServerSocket();
         ss.bind(address);

         executorService = Executors.newCachedThreadPool();

         running.set(true);
         executorService.submit(this);
      }
   }
737565
def start_server(self):
        """"""
        if self.server is None:
            self.port = select_port(default_port=self.DEFAULT_PORT)
            self.set_home_url('http://localhost:%d/' % self.port)
        elif self.server.isRunning():
            self.server.server_started.disconnect(self.initialize_continued)
            self.server.quit()
        self.server = PydocServer(port=self.port)
        self.server.server_started.connect(self.initialize_continued)
        self.server.start()
254845
public void start() {
    proxy.setTrustAllServers(true);
    if (outsideProxy != null) {
      proxy.setChainedProxy(getProxyAddress(outsideProxy));
    }

    addRequestFilter("authentication", new AuthenticationFilter());
    addRequestFilter("requestSizeWatchdog", new RequestSizeWatchdog());
    addResponseFilter("responseSizeWatchdog", new ResponseSizeWatchdog());
    addResponseFilter("download", new FileDownloadFilter(config));

    proxy.start(config.proxyPort());
    port = proxy.getPort();
  }
267305
public void start() {
      initMBeanServer(globalConfig);

      if (mBeanServer != null) {
         Collection<ComponentRef<?>> components = basicComponentRegistry.getRegisteredComponents();
         resourceDMBeans = Collections.synchronizedCollection(getResourceDMBeansFromComponents(components));

         registrar.registerMBeans(resourceDMBeans);
         needToUnregister = true;
      }
      stopped = false;
   }
305743
public void start()
  {
    _systemManager.start();
    
    logStartComplete();

    // non-daemon thread to prevent quick exit
    Thread thread = new Thread(this::join);
    thread.setName("baratine-join");
    thread.start();
  }
1311874
public void start() throws Exception {
        // verify server is NOT null
        if (server == null) {
            throw new NullPointerException("Internal server instance was null, server not configured perhaps?");
        }

        logger.info("HttpServer [{}] version [{}] using Jetty [{}]", configuration.safeGetName(), com.cloudhopper.jetty.Version.getLongVersion(),
		    server.getVersion());
        logger.info("HttpServer [{}] on [{}] starting...", configuration.safeGetName(), configuration.getPortString());

        // try to start jetty server -- if it fails, it'll actually keep running
        // so if an exception occurs, we'll make to stop it afterwards and rethrow the exception
        try {
            server.start();
        } catch (Exception e) {
            // make sure we stop the server
            try { this.stop(); } catch (Exception ex) { }
            throw e;
        }

        logger.info("HttpServer [{}] on [{}] started", configuration.safeGetName(), configuration.getPortString());
    }
749505
def start_server(self):
        
        if self._server is None:
            self._server = SimpleServer()
            self._server.createPV(prefix=self._options.prefix,
                                  pvdb={k: v.config for k, v in self.interface.bound_pvs.items()})
            self._driver = PropertyExposingDriver(interface=self.interface,
                                                  device_lock=self.device_lock)
            self._driver.process_pv_updates(force=True)

            self.log.info('Started serving PVs: %s',
                          ', '.join((self._options.prefix + pv for pv in
                                     self.interface.bound_pvs.keys())))
1370106
protected void startServerImpl() {
        SelendroidLogger.info("*** ServerInstrumentation#startServerImpl() ***");
        if (serverThread != null && serverThread.isAlive()) {
            return;
        }

        if (serverThread != null) {
            stopServer();
        }

        serverThread = new HttpdThread(this, serverPort);
        serverThread.startServer();
    }
207118
public void startUp() throws Exception {
    logger.info(String.format("Starting RPC server on port %d", port));
    ServerBootstrap bootstrap = new ServerBootstrap();

    ChannelFuture futureChannel = bootstrap.group(parentGroup, childGroup)
        .channel(channelClass)
        .childHandler(channelInitializer())
        .bind(port)
        .awaitUninterruptibly();

    if (futureChannel.isSuccess()) {
      this.channel = futureChannel.channel();
      logger.info("RPC server started successfully.");
    } else {
      logger.info("Failed to start RPC server.");
      throw new Exception(futureChannel.cause());
    }
  }
20899
@Override
	public synchronized void start() throws JMSException
    {
    	if (started)
    		return;
    	
    	log.info("Starting listener ["+getName()+"]");
    	
    	stopRequired = false;
    	
    	initServerSocket();
    	listenerThread = new Thread(this,"FFMQ-TCP-Server-"+serverSocket.getLocalPort());
    	listenerThread.start();
    	
    	started = true;
    }
1017367
public final synchronized void start() throws IOException {
		if (this.acceptor != null) {
			if (this.acceptor.getHandler() == null) {
				this.acceptor.setHandler(new TcpIpHandlerAdapter());
			}
			
			LaunchingMessageKind.ITCPIP0001.format(this.host, this.port);
			this.acceptor.bind(new InetSocketAddress(this.host, this.port));
		}
	}