/*
Start a container.
191661
function(data) {
    return Promise.each(normalizer(data), function(datum) {
      return Promise.retry(function() {
        return compose.start(datum.compose, datum.project, datum.opts);
      });
    });
  }
30254
public void startup() throws Throwable
   {
      if (started)
         throw new IllegalStateException("Container already started");

      List<String> order = new ArrayList<String>(3);
      order.add(".xml");
      order.add(".rar");
      order.add("-ra.xml");
      order.add("-ds.xml");

      boolean management = 
         Boolean.valueOf(SecurityActions.getSystemProperty("ironjacamar.embedded.management", "false"));

      KernelConfiguration kernelConfiguration = new KernelConfiguration();
      kernelConfiguration = kernelConfiguration.name("ironjacamar");
      kernelConfiguration = kernelConfiguration.home(null);
      kernelConfiguration = kernelConfiguration.classLoader(ClassLoaderFactory.TYPE_PARENT_FIRST);
      kernelConfiguration = kernelConfiguration.management(management);
      if (management)
         kernelConfiguration = kernelConfiguration.usePlatformMBeanServer(true);
      kernelConfiguration = kernelConfiguration.parallelDeploy(false);
      kernelConfiguration = kernelConfiguration.remoteAccess(false);
      kernelConfiguration = kernelConfiguration.hotDeployment(false);
      kernelConfiguration = kernelConfiguration.eventListener(new PreClassLoaderEventListener());
      kernelConfiguration = kernelConfiguration.eventListener(new PostClassLoaderEventListener());
      kernelConfiguration = kernelConfiguration.deploymentOrder(new DeploymentOrder(order));

      kernel = KernelFactory.create(kernelConfiguration);
      kernel.startup();

      if (fullProfile)
      {
         deploy(SecurityActions.getClassLoader(EmbeddedJCA.class), "naming.xml");
         deploy(SecurityActions.getClassLoader(EmbeddedJCA.class), "stdio.xml");
         deploy(SecurityActions.getClassLoader(EmbeddedJCA.class), "transaction.xml");
         deploy(SecurityActions.getClassLoader(EmbeddedJCA.class), "jca.xml");
         deploy(SecurityActions.getClassLoader(EmbeddedJCA.class), "ds.xml");
      }

      started = true;
   }
74343
protected void generateContainerStart(ResponseWriter writer, PanelGrid panelGrid, boolean idHasBeenRendered) throws IOException {
		writer.startElement("div", panelGrid);
		if (!idHasBeenRendered) {
			String clientId = panelGrid.getClientId();
			writer.writeAttribute("id", clientId, "id");
		}
		writeAttribute(writer, "dir", panelGrid.getDir(), "dir");

        Tooltip.generateTooltip(FacesContext.getCurrentInstance(), panelGrid, writer);


		String styleclass = panelGrid.getStyleClass();
		if (null != styleclass&& styleclass.trim().length()>0)
			writer.writeAttribute("class", styleclass, "class");
//		else
//			writer.writeAttribute("class", "container", "class");

		String style = panelGrid.getStyle();
		if (null != style && style.trim().length()>0)
			writer.writeAttribute("style", style, "style");
	}
1111341
public void start() {
        application = new CitrusRemoteApplication(configuration);
        port(configuration.getPort());
        application.init();

        if (!configuration.isSkipTests()) {
            new RunController(configuration).run();
        }

        if (configuration.getTimeToLive() == 0) {
            stop();
        }
    }
599176
public ContainerStart start(String containerId) {
		ContainerStart command = new ContainerStart();
		command.container(containerId);
		action.setCommand(command);
		return command;
	}
435739
def start_paragraph(self, stylename=None):
        """"""
        # Use the next paragraph style if one was set.
        if stylename is None:
            stylename = self._next_p_style or 'normal-paragraph'
        self.start_container(P, stylename=stylename)
837163
async def start(self):
        """"""

        await self.server.start()
        self.port = self.server.port
1060845
def _start(self):
        """"""
        assert self._tempdir is not None
        assert self._process is None
        self._process = subprocess.Popen(
            [
                self.paths.slapd,
                '-f', self._slapd_conf,
                '-h', self.uri,
                '-d', str(self.slapd_debug),
            ],
            stdout=sys.stdout,
            stderr=sys.stderr,
        )
        self._poll_slapd(timeout=self.max_server_startup_delay)
1236733
@Override
    public synchronized void start( BootstrapContext ctx ) throws ResourceAdapterInternalException {
        if (engine == null) {
            engine = new ModeShapeEngine();
            engine.start();
        }
    }
1349327
@SneakyThrows
    public void start(final int port) {
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bossGroup = createEventLoopGroup();
            if (bossGroup instanceof EpollEventLoopGroup) {
                groupsEpoll(bootstrap);
            } else {
                groupsNio(bootstrap);
            }
            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
            BackendExecutorContext.getInstance().getExecuteEngine().close();
        }
    }
1083828
public void start() {
    logger.info(String.format("Starting %s in container %s", this.helixInstanceName, this.taskRunnerId));

    // Add a shutdown hook so the task scheduler gets properly shutdown
    addShutdownHook();

    connectHelixManager();

    addInstanceTags();

    // Start metric reporting
    if (this.containerMetrics.isPresent()) {
      this.containerMetrics.get()
          .startMetricReportingWithFileSuffix(ConfigUtils.configToState(this.config),
              this.taskRunnerId);
    }

    if (this.serviceManager != null) {
      this.serviceManager.startAsync();
      this.serviceManager.awaitStopped();
    }
  }
943797
private void start() {
        if (m_bRunning) {
            m_logger.warn("start: Already started -- ignoring");
            return;
        }
        Locale.setDefault(Locale.ROOT);
        m_logger.info("Doradus Version: {}", getDoradusVersion());
        hookShutdownEvent();
        startServices();
        m_bRunning = true;
    }
528556
function(dockcontainer, cb) {
          var opts = confImage && confImage.options && confImage.options.start
              || {};
          grunt.log.writeln("Starting container.");
          dockcontainer.start(opts, cb);
        }
1028162
def start(self, ignore_state=False):
        """"""
        self.logger.debug("Start service")
        self._toggle_running(True, ignore_state)
1100839
public static void start(String args[]) {
        log.debug("windowsStart called");
        boot = new Boot();
        boot.start();

        // block until interrupted by stop() or the undertow dies
        while (boot.getServer().isRunning()) {
            synchronized (SERVICE) {
                try {
                    SERVICE.wait(30000);  // wait 30 seconds and check if stopped
                } catch (InterruptedException ie) {
                }
            }
        }
    }
1252194
function startMemMonitor() {
        checkInit();
        if (performance.memory !== void 0) {
            (function () {
                var update = function update() {
                    data.addSample(Math.round(mem.usedJSHeapSize / (1024 * 1024)));
                    w.addResult(data.calc());
                    setTimeout(update, 30);
                };

                var data = new Data();
                var w = new MonitorWidget("Memory", "MB", 1 /* HideMin */ | 4 /* HideMean */);
                container.appendChild(w.element);
                var mem = performance.memory;

                update();
            })();
        }
    }
283110
public void start() {
        logger.info("\n###starting...");
        try {
            Container container = this.getActualContainer();
            Server server = new ContainerServer(container);
            connection = new SocketConnection(server);
            SocketAddress address = new InetSocketAddress(port);
            socketAddress =(InetSocketAddress) connection.connect(address);
            this.isRunning = true;
            logger.info("\n#Simulator: " + this.getSimulatorName() +
                        "\n#started. " +
                        "\nListening at port: " + socketAddress.getPort());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }