Amostra de desenvolvimento de plug-ins – Estendendo o Lpex

RDz 7.5

Este trabalho mostra como estender o Lpex Editor do RDz desenvolvendo um plug-in com o uso do conjunto de ferramentas disponível na própria ferramenta. Ele cria uma amostra de plug-in com várias funcionalidades e mostra as atividades e configurações necessárias para concluir a tarefa.

Jorge Nagasaki, Especialista em TI, WSO2 Inc

Jorge Nagasaki. Especialista de TI na área de ferramentas de desenvolvimento para Mainframe , trabalhou em diversas áreas de tecnologia na IBM , desde sistemas operacionais, networking, conectividade, aplicações Cliente Servidor e Web, e em diversas plataformas. Formado na IFUSP e com especialização em Engenharia de Sistemas pela EPUSP.



22/Out/2012

Introdução

Os programas Java estão incluídos apenas para fins ilustrativos e não seguiram boas práticas de desenvolvimento, o objetivo é mostrar como desenvolver estes componentes e implementar o RDz.

A amostra inclui as seguintes funções e capacidades:

  • Comandos de usuário: Podem ser inseridos na linha de comandos do Lpex Editor. Este tutorial contém os seguintes exemplos implementados:
    • cmd0 Comando de usuário para mostrar o básico e exibir apenas uma mensagem de sucesso.
    • cmd1 Comando de usuário que mostra uma janela pop-up para que o usuário insira dados numéricos.
    • cmd2 Comando de usuário que mostra uma janela pop-up para que o usuário insira informações como ID do usuário / senha
    • cmd3 Comando de usuário que mostra o uso de pacotes Java externos (neste exemplo específico, o pacote Apache Commons Net é utilizado para uso com TCP/IP).
      Este comando de usuário faz logon no servidor FTP do z/OS e recupera uma Listagem de saída de Job em um arquivo local. As mensagens recebidas do servidor FTP também são registradas no arquivo local para verificar o resultado da transferência de arquivos do JES.
  • Ações do usuário: Ações que podem ser ativadas usando uma combinação de teclas
    • act1 Ação do usuário que mostra um exemplo para adicionar uma nova linha em branco (neste exemplo, a ação está mapeada para Ctl-4).
    • act2 Comando de ação do usuário para inserir algumas linhas de dados no arquivo sendo editado (no exemplo, um parâmetro TEST é inserido com o endereço IP da estação de trabalho do usuário). Esta ação está mapeada para Ctl-5 nas amostras.

Os exemplos implementados são ilustrativos, mas baseiam-se nas necessidades reais dos clientes. Por exemplo, act2 é implementado na função de Geração de JCL no RDz, mas o RDz não permite geração de JCL se você não estiver em um Projeto do z/OS, e também gera o parâmetro TEST somente na JCL (isso não vai funcionar quando o programa tiver Comandos SQL, porque é preciso definir o parâmetro TEST no comando RUN)

Nota: Devido à distribuição de regras de código aberto, o pacote não inclui o JAR externo do Jakarta Commons Net usado nestas amostras. Se desejar usar o mesmo pacote, você pode fazer o download da seguinte URL: http://commons.apache.org/net/


Desenvolvendo o plug-in

  • Crie um projeto de plug-in
    • Clique em File->New->Other->Plug-in Project
    • Clique em Next
    • No nome do projeto, insira o nome do plug-in em um formato de pacote, por exemplo: com.meu.lpex
    • Clique em Next
    • Em Plug-in Content (tome nota do ID do plug-in, pois ele será usado mais adiante na configuração do plugin-xml)
    • Clique em Next
    • Na página Templates, selecione Custom plug-in wizard
    • Clique em Next
    • Na página Available Templates, selecione pelo menos Pop-Up Menu, por exemplo, para que o assistente possa gerar os componentes para você. (Outros modelos podem ser selecionados, caso necessário)
    • Clique em Finish
  • Crie a classe Preload.java
    • É preciso criar a classe Preload.java para permitir que o seu plug-in seja carregado
      Esta é uma amostra de Preload.java que contém Comandos e Ações do Usuário
public void preload() {
String userCommands = LpexView.globalQuery("current.updateProfile.userCommands");
String userActions = LpexView.globalQuery("current.updateProfile.userActions");
String userKeyActions = LpexView.globalQuery("current.updateProfile.userKeyActions");

// set User Commands  in preference profile	
String newUserCommands = "cmd0 com.meu.lpex.Cmd0" ;
newUserCommands = newUserCommands + " cmd1 com.meu.lpex.Cmd1";
newUserCommands = newUserCommands + " cmd2 com.meu.lpex.Cmd2";
newUserCommands = newUserCommands + " cmd3 com.meu.lpex.Cmd3"; 
if (userCommands == null)

LpexView.doGlobalCommand("set default.updateProfile.userCommands " + newUserCommands);
else if ( userCommands.indexOf(newUserCommands) < 0)
LpexView.doGlobalCommand("set default.updateProfile.userCommands " + 
newUserCommands + " " + userCommands);


// set user Actions   in preference profile	
String newUserActions =  "acao1 com.meu.lpex.Acao1";
newUserActions = newUserActions + " acao2 com.meu.lpex.Acao2";
if (userActions == null)
LpexView.doGlobalCommand("set default.updateProfile.userActions " + newUserActions);
else if ( userActions.indexOf(newUserActions) < 0)
LpexView.doGlobalCommand("set default.updateProfile.userActions " + 
newUserActions + " " + userActions);

// set user Key Actions in preference profile
String newUserKeyActions =  "c-4 acao1";
newUserKeyActions = newUserKeyActions + " c-5 acao2"; 
if (userKeyActions == null)
LpexView.doGlobalCommand("set default.updateProfile.userKeyActions " + 
newUserKeyActions);
else if ( userKeyActions.indexOf(newUserKeyActions) < 0)
LpexView.doGlobalCommand("set default.updateProfile.userKeyActions " + 
newUserKeyActions + " " + userKeyActions);


}

}
  • Crie os componentes Java implementando os Comandos e Ações do Usuário.
    • Criando a classe Java Comando de usuário cmd0
      • No seu projeto de plug-in, clique com o botão direito no nome do pacote na pasta src.
      • Clique em new e, em seguida, em class
      • Insira o nome da classe (no caso, Cmd1) no campo Name
      • Quando o editor abrir o arquivo, insira o código Java para este comando.
        Aqui está a amostra I usada para Cmd0:
Programa Cmd1.java:
package com.meu.lpex;
//****************************************************************************
//
//    User command : so executa e envia uma mensagem no Lpex
//****************************************************************************


import com.ibm.lpex.core.LpexCommand;
import com.ibm.lpex.core.LpexStringTokenizer;
import com.ibm.lpex.core.LpexView;

public class Cmd0 implements LpexCommand {

@Override
public boolean doCommand(LpexView arg0, String arg1) {
if (arg0 != null)
{
String command = commandName(this, arg0);
arg1 = arg1.trim();
if ("?".equals(arg1)) // command help
{
arg0.doCommand("set messageText Syntax: " + command + " [<parameters>]");
return true;
}

if (arg1.length() != 0)
{
command += ' ' + arg1;
}

arg0.doCommand("set messageText Command \"" + command + "\" executed successfuly.");
}


return true;
}

public static String commandName(LpexCommand lpexCommand, LpexView lpexView)
{
String className = (lpexCommand != null)? lpexCommand.getClass().getName() : null;
if (className != null && lpexView != null)
{
LpexStringTokenizer st = new LpexStringTokenizer(lpexView.query("commands"));
while (st.hasMoreTokens())
{
String commandName = st.nextToken();
// first name found is OK (there may, though unlikely, be more)
if (className.equals(lpexView.query("commandClass." + commandName)))
{
return commandName;
}
}
}
return className;
}
            
}
  • Conclua a tarefa para os demais comandos e ações utilizando o mesmo procedimento acima inserindo o código. Os exemplos para as outras classes estão incluídos no apêndice.

Amostras das classes Java utilizadas

  • Crie um projeto “Projeto de Plug-in”.
  • Desenvolva o código do seu plug-in.
  • Abra o plugin.xml com o Editor de Manifesto de Plug-in
  • Adicione as dependências do plug-in (por exemplo: com.ibm.lpex)
    • Clique na guia Dependencies
    • Na seção Plugins obrigatória, clique em Add
    • Em Plugin Selection, selecione os plug-ins ( por exemplo: com.ibm.lpex, se você estiver estendendo o lpex editor)
    • Clique em OK
    • Em Automated Management of Dependencies, adicione os mesmos pacotes
    • Clique na guia Extensions
    • Na seção All extensions, clique em Add
    • Na janela pop-up Extension Point Selection, selecione as extensões requeridas pelo plug-in.
      Função do Plug-inSelecione o plug-in
      Menus pop-uporg.eclipse.ui.popupMenus
      Comandos de usuáriocom.ibm.lpex.preload
    • Clique na extensão com.ibm.lpex.preload e, na seção Extension Details, insira no campo ID o ID do seu plug-in (o padrão é o projeto):
      com.meu.lpex
    • Expanda a árvore da extensão clicando no sinal de mais à esquerda de com.ibm.lpex.preload; o seu pacote deve aparecer com Preload
    • Clique na subentrada (no caso, com.meu.lpex.Preload (preload))
    • Na seção Extension Element Details, insira o campo class:
      com.meu.lpex.Preload

Incluindo um jar externo no pacote de plug-in

  • Incluindo um jar externo (por exemplo, org.apache.common.net)
    • Em Plugin Project, crie uma pasta (exemplo: bundle)
    • Importe o JAR externo que você precisa incluir no plug-in usando o tipo “Sistema de Arquivos” para a pasta bundle
    • Edite o plugin.xml (clique duas vezes em plugin.xml)
    • Clique na guia Build e em Add Library
    • Em Add Entry, insira “.” (sem as aspas)
    • Clique em Add Folder e insira /src (esta é a pasta onde você cria seus programas Java)
    • Na seção Binary Build, verifique se você selecionou o seguinte
      Meta-inf
      bundle (inclui o jar externo)
      plugin.properties
      plugin.xml
    • Clique na guia Runtime
    • Na seção Classpath, clique em Add
    • Na janela Jar Selection, selecione os arquivos jar na pasta bundle (isso definirá classpath para permitir que os programas Java acessem o jar)
    • Verifique as propriedades de compilação clicando na guia build.properties
      Este é um exemplo:
      source.. = src/
      output.. = bin/
      bin.includes = plugin.xml,\
                   .,\
              META-INF/,\
          plugin.properties,\
          bundle/commons-net-ftp-2.0.jar
      additional.bundles = org.apache.commons.net
    • Verifique o arquivo MANIFEST.MF clicando na guia MANIFEST.MF
      Exemplo de Manifest.mf:
      Manifest-Version: 1.0
      Bundle-ManifestVersion: 2
      Bundle-Name: %Bundle-Name.0
      Bundle-SymbolicName: com.meu.lpex; singleton:=true
      Bundle-Version: 1.0.0
      Bundle-Activator: com.meu.lpex.Activator
      Bundle-Vendor: %Bundle-Vendor.0
      Require-Bundle: org.eclipse.ui,
        org.eclipse.core.runtime,
        org.eclipse.core.resources,
        com.ibm.lpex;bundle-version="3.4.2",
        com.ibm.lpex.doc.isv;bundle-version="3.4.2",
        com.ibm.lpex.doc.user;bundle-version="3.4.2",
        org.apache.commons.net;bundle-version="1.4.1";visibility:=reexport
      Bundle-RequiredExecutionEnvironment: JavaSE-1.6
      Bundle-ActivationPolicy: lazy
      Bundle-Localization: plugin
      Export-Package: com.meu.lpex,
        org.apache.commons.net,
        org.apache.commons.net.ftp,
        org.apache.commons.net.ftp.parser,
        org.apache.commons.net.io,
        org.apache.commons.net.util
      Bundle-ClassPath: .,
        bundle/commons-net-ftp-2.0.jar
    • Verifique o plugin.xml clicando na guia plugin.xml.
      Exemplo de plugin.xml
      <?xml version="1.0" encoding="UTF-8"?>
      <?eclipse version="3.4"?>
      <plugin>
      
        <extension
             point="org.eclipse.ui.popupMenus">
          <objectContribution
                objectClass="org.eclipse.core.resources.IFile"
                id="com.meu.lpex.contribution1">
              <menu
                    label="New Submenu"
                    path="additions"
                    id="com.meu.lpex.menu1">
                  <separator
                        name="group1">
                  </separator>
             </menu>
             <action
                     label="Acao 1"
                     class="com.meu.lpex.Acao1"
                     menubarPath="com.meu.lpex/group1"
                     enablesFor="1"
                     id="com.meu.lpex.Acao1">
             </action>
          </objectContribution>
        </extension>
        <extension
              id="com.meu.lpex"
              point="com.ibm.lpex.preload">
           <preload
                 class="com.meu.lpex.Preload">
           </preload>
        </extension>
      
      </plugin>

Exporte o plug-in para distribuição

Agora que você criou o plug-in, é preciso exportá-lo como um arquivo zip para distribuição ao RDz para que possa ser usado.

  • Abra o plug-in xml clicando duas vezes no arquivo plugin.xml no seu projeto de plug-in
  • No editor de manifesto do plug-in, clique na guia Overview
  • Na seção Exporting, clique no link Organize Manifest Wizard
  • Na janela pop-up Organize Manifest Wizard, clique em Finish
  • Clique no link Externalize String Wizard
  • Finalmente, clique no link Export Wizard
  • Em Deployable plug-ins and fragments, selecione seu projeto de plug-in (neste caso, “com.meu.lpex”)
  • Clique na guia Destination e selecione o diretório para gravar o plug-in exportado
  • Clique na guia Options e selecione a opção Package plug-ins as individual JAR archives.
  • Clique em Finish
  • No diretório que você escolher em "Destination”, o plug-in será exportado com o nome do projeto mais o ID de versão.

Instalação do plug-in no RDz

  • Copie o arquivo de plug-in Jar para o diretório de plug-ins do RDz <diretório de instalação do RDz>\SDP\plugin )
  • Reinicie o RDz com a opção –clean
  • Depois de iniciar o RDz ( este processo será mais longo devido à opção –clean), verifique as preferências do Lpex para ver se as configurações foram definidas corretamente
    • Clique em Windows->Preference
    • Expanda a árvore no Lpex Editor e localize as entradas para User Actions, User Commands and User Key Actions e verifique se todas as definições estão corretas (isso é feito pela classe Preload)

      Ações do usuário
      Comandos de usuário

      Ações de chave do usuário

      Você também pode configurar essas entradas manualmente nos painéis, em vez de fazer o procedimento automático na classe java Preload.
  • Teste os Comandos de usuário
    • Abra um arquivo no Lpex Editor
    • Insira o primeiro comando na linha de comandos ( cmd0)

      Comando cmd0:
    • Teste os outros comandos:

      Comando cmd1:

      Comando cmd3:
      Nesta amostra, faça o download da lista de saída de uma tarefa (inserida como parâmetro) e copie para sua unidade local (na amostra apresentada, a cópia é feita para c:\temp)

      Teste a ação do usuário Action2:
      Posicione o cursor no final da linha no último Parm do comando Run em SYSTSIN e pressione Ctrl-5 (esta é a configuração para Action2); assim, você verá que o plug-in inserirá uma continuação na posição atual e adicionará o parâmetro TEST com o endereço IP preenchido.

Amostras das classes Java utilizadas

Classe Java Acao1
package com.meu.lpex;

import com.ibm.lpex.core.LpexAction;
import com.ibm.lpex.core.LpexView;
//***********************************************************************
//Action to insert a continuation and a new line
//
//***********************************************************************
public class Acao1 implements LpexAction {

      @Override
      public boolean available(LpexView view) {
      return view.currentElement() != 0 && !view.queryOn("readonly");

      }

      @Override
      public void doAction(LpexView view) {
// go to end of line
      view.doAction(view.actionId("contextEnd"));
// insere ;		
      view.doDefaultCommand("insertText -");

// insere new line e posiciona cursor no inicio
      view.doAction(view.actionId("openLine"));

      }
          
}
Classe Java Acao2
package com.meu.lpex;

import java.net.InetAddress;
import java.net.UnknownHostException;

import com.ibm.lpex.core.LpexAction;
import com.ibm.lpex.core.LpexView;
//***********************************************************************
//Action to insert the TEST parameter for Debug
//
//***********************************************************************
  public class Acao2 implements LpexAction {

    @Override
      public boolean available(LpexView view) {
      return view.currentElement() != 0 && !view.queryOn("readonly");


      }

    @Override
      public void doAction(LpexView view) {
// go to end of line
        InetAddress host;
        String IpAddress;
        String parm1 = "      PARM='/TEST(,,,TCPIP&";
        String parm2 = "%8001:*)'";
        String texto;
        view.doAction(view.actionId("contextEnd"));
// insere ;		
        view.doDefaultCommand("insertText   -");

// insere new line e posiciona cursor no inicio
        view.doAction(view.actionId("openLine"));
        try {
            host = InetAddress.getLocalHost();
            IpAddress = host.getHostAddress();
            texto = parm1 + IpAddress + parm2;
            }  catch (UnknownHostException e) {
            texto = "Exception ";
            }
        view.doDefaultCommand("insertText " + texto);

    }
          
}
Classe Java para Cmd0
package com.meu.lpex;
//****************************************************************************
//
//    User command : so executa e envia uma mensagem no Lpex
//****************************************************************************


import com.ibm.lpex.core.LpexCommand;
import com.ibm.lpex.core.LpexStringTokenizer;
import com.ibm.lpex.core.LpexView;

  public class Cmd0 implements LpexCommand {

    @Override
      public boolean doCommand(LpexView arg0, String arg1) {
      if (arg0 != null)
      {
      String command = commandName(this, arg0);
      arg1 = arg1.trim();
      if ("?".equals(arg1)) // command help
      {
      arg0.doCommand("set messageText Syntax: " + command + " [<parameters>]");
      return true;
      }

      if (arg1.length() != 0)
      {
        command += ' ' + arg1;
      }

      arg0.doCommand("set messageText Command \"" + command + 
      "\" executed successfuly.");
      }


      return true;
      }
      public static String commandName(LpexCommand lpexCommand, LpexView lpexView)
      {
      String className = (lpexCommand != null)? lpexCommand.getClass().getName() : null;
      if (className != null && lpexView != null)
      {
      LpexStringTokenizer st = new LpexStringTokenizer(lpexView.query("commands"));
      while (st.hasMoreTokens())
      {
      String commandName = st.nextToken();
 // first name found is OK (there may, though unlikely, be more)
      if (className.equals(lpexView.query("commandClass." + commandName)))
      {
      return commandName;
      }
      }
      }
      return className;
      }

}
Classe Java para Cmd2
  package com.meu.lpex;
  //*******************************************************************************
  //    User command para fazer popup de janela para login  
  //*******************************************************************************
  
  import org.eclipse.swt.SWT;
  
  import org.eclipse.swt.layout.GridData;
  import org.eclipse.swt.layout.GridLayout;
  import org.eclipse.swt.widgets.Button;
  import org.eclipse.swt.widgets.Dialog;
  import org.eclipse.swt.widgets.Display;
  import org.eclipse.swt.widgets.Event;
  import org.eclipse.swt.widgets.Label;
  import org.eclipse.swt.widgets.Listener;
  import org.eclipse.swt.widgets.Shell;
  import org.eclipse.swt.widgets.Text;
  
  import com.ibm.lpex.core.LpexCommand;
  import com.ibm.lpex.core.LpexStringTokenizer;
  import com.ibm.lpex.core.LpexView;
  
  public class Cmd2 implements LpexCommand {
  
  @Override
  public boolean doCommand(LpexView arg0, String arg1) {
  if (arg0 != null)
  {
  String nome;  
  String senha;   
  String command = commandName(this, arg0);
  arg1 = arg1.trim();
  if ("?".equals(arg1)) // command help
  {
  arg0.doCommand("set messageText Syntax: " + command + " [<parameters>]");
    return true;
    }
    
    if (arg1.length() != 0)
    {
    command += ' ' + arg1;
    }
    
//-------------------------------------------------------------------------
    nome = "antes shell ";
    Shell shell = new Shell();
    Login dialog = new Login(shell);
    dialog.open();
    nome = dialog.getNome();
    senha = dialog.getSenha(); 
    
    
//--------------------------------------------------------------------------    
    
    arg0.doCommand("set messageText Command \"" + command + "\" 
    Executou o comando. Nome = " + nome + "; senha = " + senha );
    }
    
    
    return true;
    }
    /**
    * Returns the name assigned to an instance of a user-defined command
    * in the specified view.
    *
    * @param lpexCommand instance of an LPEX command
    * @param lpexView a document view in which it is defined
    * @return command name as defined with e.g., set commandClass.
    */
    public static String commandName(LpexCommand lpexCommand, LpexView lpexView)
    {
    String className = (lpexCommand != null)? lpexCommand.getClass().getName() : null;
    if (className != null && lpexView != null)
    {
    LpexStringTokenizer st = new LpexStringTokenizer(lpexView.query("commands"));
    while (st.hasMoreTokens())
    {
    String commandName = st.nextToken();
    // first name found is OK (there may, though unlikely, be more)
    if (className.equals(lpexView.query("commandClass." + commandName)))
    {
    return commandName;
    }
    }
    }
    return className;
    }
    public class Login extends Dialog {
    Double valor;
    String nomevalue;
    String senhavalue;
    /**
    * @param parent
    */
    public Login(Shell parent) {
    super(parent);
    }
    
    /**
    * @param parent
    * @param style
    */
    public Login(Shell parent, int style) {
    super(parent, style);
    }
    
    /**
    * Makes the dialog visible.
    * 
    * @return
    */
    public String getNome()
    {
    return nomevalue;  
    }
    public String getSenha()
    {
    return senhavalue;  
    }
    
    public Double open() {
    Shell parent = getParent();
    final Shell shell =
    new Shell(parent, SWT.TITLE | SWT.BORDER | SWT.APPLICATION_MODAL);
    shell.setText("Login");
    
    shell.setLayout(new GridLayout(2, true));
    
    Label label = new Label(shell, SWT.NULL);
    label.setText("Please enter Name and password:");
    
    final Text nome = new Text(shell, SWT.SINGLE | SWT.BORDER);
    Label label1 = new Label(shell, SWT.NULL);
    label1.setText("Password:");
    final Text senha = new Text(shell,SWT.SINGLE | SWT.BORDER);
    senha.setEchoChar('*');
    final Button buttonOK = new Button(shell, SWT.PUSH);
    buttonOK.setText("Ok");
    buttonOK.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END));
    Button buttonCancel = new Button(shell, SWT.PUSH);
    buttonCancel.setText("Cancel");
    buttonOK.setEnabled(false);
    
    nome.addListener(SWT.Modify, new Listener() {
    public void handleEvent(Event event) {
    
    nomevalue = nome.getText();
    if (!nomevalue.equals("") ) 
    buttonOK.setEnabled(true);
    
    else 
    buttonOK.setEnabled(false);
    
    }
    });
    
    buttonOK.addListener(SWT.Selection, new Listener() {
    public void handleEvent(Event event) {
    senhavalue = senha.getText();	
    nomevalue = nome.getText();
    
    shell.dispose();
    }
    });
    
    buttonCancel.addListener(SWT.Selection, new Listener() {
    public void handleEvent(Event event) {
    valor = null;
    shell.dispose();
    }
    });
    
    shell.addListener(SWT.Traverse, new Listener() {
    public void handleEvent(Event event) {
    if(event.detail == SWT.TRAVERSE_ESCAPE)
    event.doit = false;
    }
    });
    
    nome.setText("");
    shell.pack();
    shell.open();
    
    Display display = parent.getDisplay();
    while (!shell.isDisposed()) {
    if (!display.readAndDispatch())
    display.sleep();
    }
    
    return valor;
    }
    }
Classe Java para Cmd3
package com.meu.lpex;
//*******************************************************************************
//    User command to show popup window for userid and password 
//     and retrieve a JOB Ourput listing from JES
//*******************************************************************************


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;

import org.apache.commons.net.PrintCommandListener;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Dialog;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

import com.ibm.lpex.core.LpexCommand;
import com.ibm.lpex.core.LpexStringTokenizer;
import com.ibm.lpex.core.LpexView;

public class Cmd3 implements LpexCommand {

	@Override
	public boolean doCommand(LpexView arg0, String arg1) {
		  if (arg0 != null)
		   {
			String erro_mensagem = null;  
			String nome;  
			String senha;   
		    String command = commandName(this, arg0);
		    arg1 = arg1.trim();
		    if ("?".equals(arg1)) // command help
		     {
		      arg0.doCommand("set messageText Syntax: " + command +
		      "[<parameters>]");
		      return true;
		     }

		    if (arg1.length() != 0)
		     {
		      command += ' ' + arg1;
		     }
		    
//---------------------------------------------------------------------------
//   Obtem dados de Login.
//---------------------------------------------------------------------------
		    nome = "antes shell ";
		    Shell shell = new Shell();
		    Login dialog = new Login(shell);
		    dialog.open();
		    nome = dialog.getNome();
		    senha = dialog.getSenha();

//--------------------------------------------------------------------------
//   Obtain JOB Listing from JES
//--------------------------------------------------------------------------	
		  
		    Ftpmvs ftp = new Ftpmvs();
		    ftp.setUserName(nome);
		    ftp.setPassword(senha);
        	ftp.setFilename(arg1);    // set file name
            erro_mensagem = ftp.conecta("172.24.200.3");		    
            if ( erro_mensagem == null)
            {
            	// Connect OK
            	erro_mensagem = ftp.recebe();
            	if (erro_mensagem == null)
            		erro_mensagem = "Sysout received successfully";
            }
             
		    arg0.doCommand("set messageText Command \"" + command + "\" 
		    Executou o comando. Nome = " + nome + ":" + erro_mensagem );
		   }


		return true;
	}
	 /**
	  * Returns the name assigned to an instance of a user-defined command
	  * in the specified view.
	  *
	  * @param lpexCommand instance of an LPEX command
	  * @param lpexView a document view in which it is defined
	  * @return command name as defined with e.g., set commandClass.
	  */

Amostras das classes Java utilizadas

Classe Java para Cmd3
	 public static String commandName(LpexCommand lpexCommand, LpexView lpexView)
	 {
	  String className = (lpexCommand != null)? 
	  lpexCommand.getClass().getName() : null;
	  if (className != null && lpexView != null)
	   {
	    LpexStringTokenizer st = new LpexStringTokenizer(lpexView.query("commands"));
	    while (st.hasMoreTokens())
	     {
	      String commandName = st.nextToken();
	      // first name found is OK (there may, though unlikely, be more)
	      if (className.equals(lpexView.query("commandClass." + commandName)))
	       {
	        return commandName;
	       }
	     }
	   }
	  return className;
	 }
	 public class Login extends Dialog {
		  Double valor;
          String nomevalue;
          String senhavalue;
		  /**
		   * @param parent
		   */
		  public Login(Shell parent) {
		    super(parent);
		  }

		  /**
		   * @param parent
		   * @param style
		   */
		  public Login(Shell parent, int style) {
		    super(parent, style);
		  }

		  /**
		   * Makes the dialog visible.
		   * 
		   * @return
		   */
		  public String getNome()
		  {
			return nomevalue;  
		  }
		  public String getSenha()
		  {
			return senhavalue;  
		  }
		  
		  public Double open() {
		    Shell parent = getParent();
		    final Shell shell =
		      new Shell(parent, SWT.TITLE | SWT.BORDER | SWT.APPLICATION_MODAL);
		    shell.setText("Login");

		    shell.setLayout(new GridLayout(2, true));

		    Label label = new Label(shell, SWT.NULL);
		    label.setText("Please enter Name and password:");

		    final Text nome = new Text(shell, SWT.SINGLE | SWT.BORDER);
  		    Label label1 = new Label(shell, SWT.NULL);
		    label1.setText("Password:");
		    final Text senha = new Text(shell,SWT.SINGLE | SWT.BORDER);
            senha.setEchoChar('*');
		    final Button buttonOK = new Button(shell, SWT.PUSH);
		    buttonOK.setText("Ok");
		    buttonOK.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END));
		    Button buttonCancel = new Button(shell, SWT.PUSH);
		    buttonCancel.setText("Cancel");
            buttonOK.setEnabled(false);

		    nome.addListener(SWT.Modify, new Listener() {
		      public void handleEvent(Event event) {
		        	
		        	nomevalue = nome.getText();
		          if (!nomevalue.equals("") ) 
			          buttonOK.setEnabled(true);
     	        	  
		          else 
			          buttonOK.setEnabled(false);

		      }
		    });

		    buttonOK.addListener(SWT.Selection, new Listener() {
		      public void handleEvent(Event event) {
		          senhavalue = senha.getText();	
		          nomevalue = nome.getText();

		    	  shell.dispose();
		      }
		    });

		    buttonCancel.addListener(SWT.Selection, new Listener() {
		      public void handleEvent(Event event) {
		        valor = null;
		        shell.dispose();
		      }
		    });
		    
		    shell.addListener(SWT.Traverse, new Listener() {
		      public void handleEvent(Event event) {
		        if(event.detail == SWT.TRAVERSE_ESCAPE)
		          event.doit = false;
		      }
		    });

		    nome.setText("");
		    shell.pack();
		    shell.open();

		    Display display = parent.getDisplay();
		    while (!shell.isDisposed()) {
		      if (!display.readAndDispatch())
		        display.sleep();
		    }

		    return valor;
		  }
	 }

	 public class Ftpmvs {
	     FTPClient ftp; 
	     String serverName ="172.24.200.3"  ; 
	     String userName = "userid" ; 
	     String password ="********" ;
		   OutputStream fo ;
           String filename;
       public void setFilename(String localname) {
    	   filename = localname;
       }
       
	   public void setUserName(String nome)
	   {
		   userName = nome;
	   }
	   public void setPassword(String senha) {
		   password = senha;
	   }
	   
	   public String conecta(String servidor) {
	//	 String mensagem = null;  
		 serverName = servidor;  
		 String localfilename = "c:\\temp\\" + filename;
		   try {
			   fo = new FileOutputStream(localfilename);
			   } catch(Exception e) {
				   return ("*error Open Output file");
			   }

		 try {
	     ftp = new FTPClient() ; 
	     
		 } catch (NoClassDefFoundError e)
		 {
			 
			 return ("Classe nao encontrado:" + e.getMessage());
		 }
// set loca file to log messages received from FTP		 
         ftp.addProtocolCommandListener(new PrintCommandListener(
                 new PrintWriter(fo)));     


		 //Connect to the server 
	     try { 
	    	 int reply;
	          ftp.connect (serverName) ; 
	          String replyText =ftp.getReplyString()  ; 
              reply = ftp.getReplyCode();
              
              if (!FTPReply.isPositiveCompletion(reply))
              {
                  ftp.disconnect();
                  return("FTP server refused connection.");
              }

	     } 
	     catch (Exception  e)  {
	               return ( "Erro na conexao") ; 
	     } 
	     //Verify error from connect
	     
	     //Login to the server 
	     try { 
	              if(!ftp.login (userName, password)) 
	              {
	            	  return("Login Error");
	              }
	               String replyText = ftp.getReplyString() ; 
	               System.out.println (replyText); 
	     } catch (Exception e) { 
	               return( "Erro no Login" );
	     } 
	     return (null);
	   }
	     //Tell server that the file will have JCL records
	   public void submete(String texto) {
	     try { 
	               ftp.site ("filetype=jes") ; 
	               String replyText = ftp.getReplyString() ; 
	               System.out.println (replyText) ; 
	     } 
	     catch 	(Exception e) { 
	               e.printStackTrace() ; 
	     } 
	     //Submit the job from the text file.Use 
	     \\ to avoid using escape notation 
	     try { 
	               FileInputStream inputStream = new FileInputStream 
	               ("C:\\temp\\job.txt") ; 
	               ftp.storeFile (serverName,inputStream) ; 
	              
	               String replyText = ftp.getReplyString() ; 
	               System.out.println (replyText) ; 
	     } 
	     catch	(Exception e) { 
	               e.printStackTrace() ; 
	     } 	     //Quit the server 
	     try { 
	                 ftp.quit() ; 
	     } 
	     catch 	(Exception e) { 
	                e.printStackTrace() ; 
	     } 
	   }
	   public String recebe() {
//		   OutputStream fo ;
		   //String localfilename = "c:\\temp\\" + filename;

		   try {
           ftp.enterLocalPassiveMode();   // normally behind firewall

           ftp.site ("filetype=jes") ; 
		   ftp.retrieveFile(filename, fo); 
		   fo.close();
		   ftp.logout();
		   } catch ( Exception e)
		   {
		   return ("*error getting Syout");
		   }
		   
		   // record the file 
		   return (null);
	   }
	 }
	  
}

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Rational
ArticleID=830842
ArticleTitle=Amostra de desenvolvimento de plug-ins – Estendendo o Lpex
publish-date=10222012