Usando a API do Servidor Integrado para Iniciar e Parar Servidores

Com o WebSphere eXtreme Scale, é possível usar uma API programática para gerenciar o ciclo de vida de servidores e contêineres integrados. É possível configurar programaticamente o servidor com qualquer uma das opções que também podem ser configuradas com as opções de linha de comandos ou com as propriedades de servidor baseadas em arquivo. Você pode configurar o servidor integrado para que seja um servidor de contêiner, um serviço de catálogo ou ambos. 

Antes de Iniciar

É necessário ter um método para executar o código a partir de um Java Virtual Machine já existente. As classes doeXtreme Scale deverão estar disponíveis na árvore do carregador de classes.

Sobre Esta Tarefa

É possível executar muitas tarefas de administração com a API de Administração. Um uso comum da API é como um servidor interno para armazenar o estado do aplicativo da Web. O servidor da Web pode iniciar um servidorWebSphere eXtreme Scale integrado, relatar o servidor de contêiner para o serviço de catálogo e o servidor será, em seguida, incluído como um membro de uma grade distribuída maior. Esse uso pode fornecer escalabilidade e alta disponibilidade para um armazém de dados voláteis do contrário.

É possível controlar programaticamente o ciclo de vida completo de um servidor eXtreme Scale integrado. Os exemplos são genéricos o máximo possível e mostram apenas exemplos de código diretos para etapas realçadas.

Procedimento

  1. Obtenha o objeto ServerProperties da classe ServerFactory e configure quaisquer opções necessárias. Para obter mais informações sobre a interface ServerProperties, consulteInterface ServerProperties.
    Cada servidor eXtreme Scale possui um conjunto de propriedades configuráveis.Quando um servidor é iniciado na linha de comandos, essas propriedades são configuradas para os padrões, mas é possível substituir várias propriedades ao fornecer uma origem ou arquivo externo. No escopo integrado, é possível configurar diretamente as propriedades com um objeto ServerProperties. Essas propriedades devem ser configuradas antes de obter uma instância do servidor a partir da classe ServerFactory. O seguinte exemplo de fragmento de código obtém um objeto ServerProperties, configura o campo CatalogServiceBootStrap e inicializa várias configurações do servidor opcionais. Consulte a documentação da API para obter uma lista de definições configuráveis.
    ServerProperties props = ServerFactory.getServerProperties();
    props.setCatalogServiceBootstrap("host:port");
    // necessário para conectar a um serviço de catálogo específico props.setServerName("ServerOne"); // nome do servidor props.setTraceSpecification("com.ibm.ws.objectgrid=all=enabled");
    // Configura a espec. de rastreio
  2. Se desejar que o servidor seja um serviço de catálogo, obtenha o objeto CatalogServerProperties.

    Para obter mais informações sobre a interface CatalogServerProperties, consulte a Interface CatalogServerProperties.

    Cada servidor integrado pode ser um serviço de catálogo, um servidor de contêiner ou ambos. O seguinte exemplo obtém o objeto CatalogServerProperties, ativa a opção de serviço de catálogo e define várias configurações de serviço de catálogo.
    CatalogServerProperties catalogProps = ServerFactory.getCatalogProperties();
    catalogProps.setCatalogServer(true); // false por padrão,
    necessário para configurar como um serviço de catálogo catalogProps.setQuorum(true); // ativa / desativa quorum
  3. Obtenha a instância Servidor a partir da classe ServerFactory. A instância doServidor é um singleton de escopo definido de processo responsável por gerenciar a associação na grade. Depois que essa instância for inicializada, esse processo será conectado e altamente disponibilizado com outros servidores na grade.

    Para obter mais informações sobre a interface Servidor, consulteInterface do Servidor. Para obter mais informações sobre a classe ServerFactory, consulte a Classe ServerFactory.

    A seguir há um exemplo de como criar a instância Servidor:
     Server server = ServerFactory.getInstance();
    Revisando o exemplo anterior, a classeServerFactory fornece um método estático que retorna uma instância Servidor. A classe ServerFactory deve ser a única interface para obter uma instância Servidor. Portanto, a classe garante que a instância seja um singleton ou uma instância para cada JVM ou carregador de classes isolado. O método getInstance inicializa a instância Servidor. É necessário configurar todas as propriedades do servidor antes de inicializar a instância. A classe Servidor é responsável por criar novas instâncias do Contêiner. É possível usar ambas as classes ServerFactory e Servidor para gerenciar o ciclo de vida da instância do Servidor integrada.

    Para obter mais informações sobre a interface Contêiner, consulte a Interface do Contêiner.

  4. Inicie uma instância Contêiner usando a instância do Servidor.
    Antes que os shards possam ser colocados em um servidor integrado, é necessário criar um contêiner no servidor. A interface Servidor possui um método createContainer que utiliza um argumentoDeploymentPolicy. O seguinte exemplo utiliza a instância do servidor obtida para criar um contêiner usando um arquivo DeploymentPolicy criado. Note que os contêineres requerem um carregador de classes que possui os binários do aplicativo disponíveis para serialização. É possível tornar esses binários disponíveis ao chamar o métodocreateContainer com o carregador de classes de contexto Encadeamento para configurar o carregador de classes que deseja usar.
    DeploymentPolicy policy = DeploymentPolicyFactory.createDeploymentPolicy
    (new URL("file://urltodeployment.xml"), new URL("file://urltoobjectgrid.xml")); Container container = server.createContainer(policy);
  5. Remover e limpar um contêiner.

    É possível remover e limpar um servidor de contêiner usando o método teardown em execução na instância do Contêiner obtida. Executar o método teardown adequadamente em um contêiner limpa o contêiner e remove o contêiner do servidor integrado.  

    O processo de limpeza do contêiner inclui o movimento e a remoção de todos os shards que são colocados dentro desse contêiner. Cada servidor pode conter muitos contêineres e shards. Limpar um contêiner não afeta o ciclo de vida da instância do Servidor pai. O seguinte exemplo demonstra como executar o método teardown em um servidor. O método teardown é disponibilizado por meio da interface ContainerMBean. Ao usar a interface ContainerMBean, se você não tiver mais acesso programático nesse contêiner, ainda poderá remover e limpar o contêiner com o MBean. Um métodoterminate também existe na interface Contêiner, mas não use-o a menos que realmente seja necessário. Esse método é mais forte e não coordena o movimento e a limpeza apropriados dos shards.
    container.teardown();
  6. Parar o servidor integrado.
    Ao parar um servidor integrado, todos os contêineres e shards que estiverem em execução também são parados no servidor. Ao parar um servidor integrado, é necessário limpar todas as conexões abertas e mover ou remover todos os shards. O seguinte exemplo mostra como parar um servidor e o uso do métodowaitFor na interface do Servidor para garantir que a instância do Servidor seja parada completamente. Da mesma forma que o exemplo de contêiner, o método stopServer é disponibilizado por meio da interface ServerMBean. Com essa interface, é possível parar um servidor com o bean gerenciado (MBean) correspondente.
    ServerFactory.stopServer();  // Usa o factory para interromper o singleton de Servidor
     // ou
    server.stopServer(); // Usa a instância do Servidor diretamente
    server.waitFor(); // Retorna quando o servidor tiver concluído 
    corretamente os procedimentos de encerramento
    Código de exemplo completo:
     import java.net.MalformedURLException;
    import java.net.URL;
    
    import com.ibm.websphere.objectgrid.ObjectGridException;
    import com.ibm.websphere.objectgrid.deployment.DeploymentPolicy;
    import com.ibm.websphere.objectgrid.deployment.DeploymentPolicyFactory;
    import com.ibm.websphere.objectgrid.server.Container;
    import com.ibm.websphere.objectgrid.server.Server;
    import com.ibm.websphere.objectgrid.server.ServerFactory;
    import com.ibm.websphere.objectgrid.server.ServerProperties;
    
    public class ServerFactoryTest {
    
        public static void main(String[] args) {
    
            try {
    
                ServerProperties props = ServerFactory.getServerProperties();
                props.setCatalogServiceBootstrap("catalogservice-hostname:catalogservice-port");
                props.setServerName("ServerOne"); // name server
                props.setTraceSpecification("com.ibm.ws.objectgrid=all=enabled"); // TraceSpec
    
                /*
                 * Na maioria dos casos, o servidor atuará apenas como um servidor de contêiner
                 * e será conectado a um serviço de catálogo externo. Essa é a forma mais
                 * disponibilizada de fazer as coisas. O trecho de código comentado a seguir
                 * ativará esse Servidor como um serviço de catálogo.
                 *
                 *
                 * CatalogServerProperties catalogProps =
                 * ServerFactory.getCatalogProperties();
                 * catalogProps.setCatalogServer(true); // ativar serviço de catálogo
                 * catalogProps.setQuorum(true); // ativar quorum
                 */
    
                Server server = ServerFactory.getInstance();
    
                DeploymentPolicy policy =
    DeploymentPolicyFactory.createDeploymentPolicy
    					(new URL("url to deployment xml"),  new URL("url to objectgrid
    xml file"));
                Container container = server.createContainer(policy);
                
                /*
                 * O shard será agora colocado nesse contêiner se os requisitos 
                 
    de implementação forem atendidos.              * Isso inclui a criação de servidor e de contêiner integrado.              *              * As linhas abaixo demonstrarão simplesmente a chamada de métodos de limpeza              */                          container.teardown();             server.stopServer();             int success = server.waitFor();         } catch (ObjectGridException e) {             // O contêiner falhou ao inicializar         } catch (MalformedURLException e2) {             // URL inválida no(s) arquivo(s) xml         }     } }