Atualizando Servidor com Horário de Verão

Com a alteração do horário de verão existe a necessidade da atualização do servidor. Para fazer essa alteração é necessário acessar como root.

Para a exibição da hora não é necessário root, apenas para a alteração.  

Exibe data e hora:

$ date

A saída exibirá algo parecido com:

Mon Oct 19 09:58:19 BRST 2015

Altera hora para 10:00 horas:

# date -s "10:00"

Informações de manual do comando:

$ man date

Outra forma:

# date -s 'hh:mm:ss'

Sendo:

hh: a hora de 00 à 23

mm: minutos com 2 dígitos de 00 a 59

ss: segundos com 2 dígitos de 00 a 59

Apenas a data:

# date mmddhhmmyyyy

Sendo:

mm: mês

dd: dia

hh: hora

mm: minuto

yyyy: ano

Outra forma:

Atualizando data

# date -s 'yyyymmdd'

yyyy: o ano com 4 dígitos

mm: o mês com 2 dígitos

dd: o dia com 2 dígitos

Atualizando hora

               

Depois de digitado o comando com os respectivos valores, digite isso para salvar as alterações (algumas distros não precisam desse comando):

# clock -w

Eu considero mais fácil ainda fazendo a conexão com um servidor de hora. No caso o NTP.

Caso não possua o ntpdate instalado você pode instalar a partir do source:http://www.ntp.org/downloads.html, ou se possui o aptitude:

# aptitude install ntpdate

Pode se encontrar uma lista de servidores ntp’s no link:http://support.ntp.org/bin/view/Servers/NTPPoolServers

Com o comando abaixo será feita uma ponte com o servidor (no caso pool.ntp.or) e a data e a hora será baixada para a máquina local onde será imediatamente atualizada:

# ntpdate pool.ntp.org

ou

# ntpdate -u ntp.usp.br

Também pode se utilizar o ip do observatório nacional:

# ntpdate -u 200.20.186.75

No meu caso em uma das máquinas o comando ntpdate constava como “depracated” (desatualizado/ não mais utilizado)

Segue o comando com a mensagem:

/home/usuario # ntpdate -u ntp.usp.br

       !!!!!!!!!!!!!!  WARNING !!!!!!!!!!!!!!!!!!

The ntpdate program is deprecated and should not be used any more.  To

quote the upstream ntp developers:

  "The functionality ntpdate offered is now provided by the ntpd daemon

  itself.  If you call ntpd with the command line option -q it will

  retrieve the current time and set it accordingly."

Please check the Network Time Protocol (NTP) daemon man page and

  http://support.ntp.org/bin/view/Dev/DeprecatingNtpdate

for further information.

You can replace the ntpdate call with "rcntp ntptimeset" to achieve an

inital poll of the servers specified in /etc/ntp.conf.

The program /usr/sbin/sntp offers comparable functionality to ntpdate.

Specifically

  sntp -P no -r pool.ntp.org

is equivalent to

  ntpdate pool.ntp.org

For further details please refer to the man page of sntp.

sntp: not enough valid responses received in time

You have new mail in /var/mail/root

Neste caso foi utilizado o commando referido na mensagem:

#  sntp -P no -r pool.ntp.org

É possível  também colocar o script na cron para ser checado de hora em hora.

# crontab –e

ou

# vi /etc/crontab

Colocar o código:

00 * * * * ntpdate -u pool.ntp.org

Ou se preferir:

*/59 * * * * ntpdate -u pool.ntp.org

Também é possível utilizando o NTP de forma automatizada para entrar e sair do horário de verão na data correta.

Para configurar o cincronismo no arquivo /etc/ntp.conf na linha server:

#vi /etc/ntp.conf

server pool.ntp.org


Para iniciar o serviço:

# service ntpd start

Ou:

# /etc/rc.d/init.d/ntpd start

Ou::

# /etc/init.d/ntp start


Para parar

# /etc/init.d/ntp stop


Para verificar os logs no /var/log/messages:

# tail /var/log/messages

Ou:

# grep ntpd /var/log/messages

Referencia:

https://timalves.wordpress.com/2011/10/11/ntp-resolvendo-problemas-com-horario-de-verao/

Mais da Classe Robot - Usando o Cursor do Mouse

Hoje selecionei um código ainda mais simples para testar a classe Robot. O código abaixo faz a impressão da palavra HELLO no Notepad com um delay de 500 milissegundos entre as letras.


import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.io.IOException;

public class Robot05{
 

  public static void main(String[] args)
                 throws AWTException,IOException{

     int keyInput[] = {
            KeyEvent.VK_H,
            KeyEvent.VK_E,
            KeyEvent.VK_L,
            KeyEvent.VK_L,
            KeyEvent.VK_O
        };

    Runtime.getRuntime().exec("notepad");

    Robot robot = new Robot();

    robot.keyPress(KeyEvent.VK_SHIFT);
    for (int cnt2 = 0;cnt2 < keyInput.length; cnt2++){
      if(cnt2 > 0){
             robot.keyRelease(KeyEvent.VK_SHIFT);
      }
      robot.keyPress(keyInput[cnt2]);
      robot.delay(500);
    }
  }
}



Uma ação bacana da classe é mover o cursor do mouse. Antes um código de programa para capturar e exibir a posição do cursor do mouse.




import java.awt.MouseInfo;


    public class Mouse {
        public static void main(String[] args) {
            while ( true ) {
                System.out.println( MouseInfo.getPointerInfo().getLocation() );
            }
        }
    }



Agora podemos posicionar o mouse em uma localização e capturar os pontos X e Y da localização definida. No programa abaixo definimos as posições que escolhemos usando o código anterior.




import java.awt.AWTException;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.event.InputEvent;


public class RobotExe {

public static void main(String[] args) {
     
 
        try {
            Robot robot = new Robot();        
         
            robot.delay(5000); // Tempo para o programa abrir        
            Point p = new Point();

            p = MouseInfo.getPointerInfo().getLocation();
            System.out.println("x = " + p.x);
            System.out.println("y = " + p.y);
         
            int x = 291;
            int y = 149;
         
            // Move mouse cursor to x, y
            robot.mouseMove(x, y);

            robot.mousePress(InputEvent.BUTTON1_MASK);
            robot.mouseRelease(InputEvent.BUTTON1_MASK);
         

            robot.mouseWheel(-100);
        } catch (AWTException e) {
            e.printStackTrace();
        }
    }
}


O próximo passo seria armazenar as posições de um intervalo de tempo em um arquivo e depois mandar executar as posições do arquivo criando um buffer de memória de movimentação do cursor. Isso seria suficiente para criar um executável no Windows que pode ser ativado em um determinado horário. Esse foi o artifício usado na história contada do post anterior.

Classe Robot Java

Em 2008 descobri esta classe em Java. A classe ficou bem famosa depois de um advento interessante. Um funcionário de uma grande corporação utilizava esta ferramenta para bater o cartão que era feito computador do usuário. A ferramenta era programada em um determinado horário e assim ele poderia sair antes e deixar o computador ligado. A ferramenta funcionava de segunda a sexta. Porém, em um dia de feriado ele esqueceu de desativar. Os superiores o chamaram para saber como ele havia entrado na empresa em um dia de feriado. Ele contou a verdade e acabou sendo demitido por justa causa.

Alguns exemplos da classe para automatização de tarefas.



Eventos de Teclado:

void keyPress(int keycode) – utilizado para simular o pressionamento de uma tecla;
void keyRelease(int keycode) – remove o status de pressionada de uma tecla utilizada pelo método keyRelease;

Eventos de Mouse:

void mouseMove(int x, int y) – move o mouse para o posição x,y;
void mousePress(int buttons) – pressiona um dos botões do mouse;
void mouseRelease(int buttons) – remove a pressão efetuada pelo método mouseRelease(int buttons);
void mouseWheel(int wheelAmt) – Indica o número de vezes que o scroll será utilizado (aceita valores negativos).

Eventos de Vídeo:

BufferedImage createScreenCapture(Rectangle screenRect) – Captura a imagem existente na tela (na verdade no dispositivo padrão de saída);
Color getPixelColor(int x, int y) – captura a cor do pixel na posição x,y;

Métodos Acessórios:

void delay(int ms) – deixa o a instância de Robot parada (sleeping) por int milisegundos;
void setAutoDelay(int ms) – informa o tempo que a instância da classe Robot deve esperar depois de gerar um evento;
int getAutoDelay() – obtém o valor do autodeley da instância de Robot;
void waitForIdle() – Aguarda até que todos os eventos que estão na fila sejam processados;
void setAutoWaitForIdle(boolean isOn) – define se a instância sempre deve aguardar se todos os eventos da fila sejam processados;
boolean isAutoWaitForIdle() – verifica o estado do autoWaitForIdle;
String toString() – esse método dispensa comentários.






No exemplo abaixo deverá abrir uma calculadora com uma operação e um bloco de notas em seguida.

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.io.IOException;

public class Robo {
private Robot robot;

public Robo() throws AWTException {
robot = new Robot();
}

/**
* Executa um comando no SO..
*/
public void execute(String comando) throws IOException {
Runtime.getRuntime().exec(comando);
robot.delay(5000); // Tempo para o programa abrir
}

/**
* Copia os dados para a área de transferência.
*/
public void copiar() {
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_C);
robot.keyRelease(KeyEvent.VK_C);
robot.keyRelease(KeyEvent.VK_CONTROL);
robot.delay(2000);
}

/**
* Cola os dados que estão na área de transferência.
*/
public void colar() {
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_CONTROL);
robot.delay(2000);
}

/**
* Executa a digitação de uma sequência de caracteres.
*/
public void executeTeclas(int... keys) {
if (keys != null) {
for (int key : keys) {
robot.keyPress(key);
robot.keyRelease(key);
}
}
robot.delay(2000); // tempo para o usuário ver o que foi digitado
}

public static void main(String[] args) throws AWTException, IOException {
Robo robo = new Robo();

// Número 25 seguido do sinal +
int[] primeira = { KeyEvent.VK_2, KeyEvent.VK_5, KeyEvent.VK_ADD };
// Número 12 seguido do sinal =
int[] segunda = { KeyEvent.VK_1, KeyEvent.VK_2, KeyEvent.VK_EQUALS };
robo.execute("calc");
robo.executeTeclas(primeira);
robo.executeTeclas(segunda);
robo.copiar();
robo.execute("notepad");
robo.colar();
}
}

Relatório de Conexões Através de Netstat com Java

O objetivo deste código de programa é monitorar conexões que são feitas na máquina. O Netstat permite exibir as conexões e as portas utilizadas no computador exibindo o computador remoto que está conectado assim como a sua porta utilizada. O objetivo principal aqui é a segurança e monitoramento da maquina. Conforme a opção do Netsat também é possível verificar qual é o programa que está sendo utilizado naquela conexão, mas essa informação em nem todos os casos é exibida. No programa, o comando roda a cada 5 minutos (300 segundos). Caso exista algum programa indevido é necessário fazer o reconhecimento e o bloqueio através do firewall. Na classe CommandLine é executado o comando, onde o Java chama o comando em CMD.EXE do sistema operacional. Na classe MyRun3 criamos o arquivo no local determinado nomeado com a data e a hora da execução. Na classe Begginer temos a programação da chamada a cada 5 minutos e da chamada principal do inicio do programa. Os pacotes devem sex exportados pelo Eclipse através da opção JAR Executável e na combobox deve ser selecionada a classe da chamada principal que contém o método Main no nosso caso a classe Begginer.


package Cap2;

import java.io.*;

public class CommandLine {
// Needed to run commands in the command line
private Runtime runtime;
private Process process;

// Output of the executed command
private String stdinData;
private String stderrData;

// Constructor
public CommandLine() {
runtime = Runtime.getRuntime();
process = null;
stdinData = "";
stderrData = "";
}

// Return executed command output data
public String getStdinData() {
return stdinData;
}

public String getStderrData() {
return stderrData;
}

// Execute a single command with all its arguments
public void execute(String command) {
try {
process = runtime.exec(command);
} catch (Exception ex) {
System.err.println(ex);
}

pullProcessData();
}

// Execute a single command in cmdArray,
// define environment settings in envp and
// set working directory to dir
public void execute(String[] cmdArray, String[] envp, File dir) {
try {
process = runtime.exec(cmdArray, envp, dir);
} catch (Exception ex) {
System.err.println(ex);
}

pullProcessData();
}

// Obtain all data sent by the process to stdout and stderr
private void pullProcessData() {
try {
StringBuffer stdinBuffer = new StringBuffer();
StringBuffer stderrBuffer = new StringBuffer();

InputStream stdinStream = process.getInputStream();
InputStream stderrStream = process.getErrorStream();

new InputStreamHandler(stdinBuffer, stdinStream);
new InputStreamHandler(stderrBuffer, stderrStream);

process.waitFor();

stdinData = stdinBuffer.toString();
stderrData = stderrBuffer.toString();
} catch (Exception ex) {
System.err.println(ex);
}
}

// Private inner class used to handle input streams
private class InputStreamHandler extends Thread {
private InputStream m_stream;
private StringBuffer m_captureBuffer;

InputStreamHandler(StringBuffer captureBuffer, InputStream stream) {
m_stream = stream;
m_captureBuffer = captureBuffer;
start();
}

public void run() {
try {
int nextChar;
while ((nextChar = m_stream.read()) != -1)
m_captureBuffer.append((char) nextChar);
} catch (IOException ioex) {
System.err.println(ioex);
}
}
}
}

package Cap2;

import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.GregorianCalendar;

public class MyRun3  {

public void executeCommand ( ) {
// TODO Auto-generated method stub

   String nomearquivo;
   StringBuilder sb = new StringBuilder();

   // cria um GregorianCalendar que vai conter a hora atual
   GregorianCalendar d = new GregorianCalendar();
   
   // anexa do StringBuilder os dados da hora
   sb.append( d.get( GregorianCalendar.YEAR) );
   sb.append( "_" );
   sb.append( d.get( GregorianCalendar.MONTH ) );
   sb.append( "_" );
   sb.append( d.get( GregorianCalendar.DAY_OF_MONTH ) );
   sb.append( "_" );
 
   sb.append( d.get( GregorianCalendar.HOUR_OF_DAY ) );
   sb.append( "h" );
   sb.append( d.get( GregorianCalendar.MINUTE ) );
   sb.append( "m" );
   sb.append( d.get( GregorianCalendar.SECOND ) );
   sb.append( "s" );

   // retorna a String do StringBuilder
   nomearquivo="d:\\filters\\logNetstat_";
   nomearquivo+=sb.toString();
   nomearquivo+=".txt";
 
 

CommandLine cl = new CommandLine();

cl.execute( "cmd /c netstat -an" );

System.out.print( cl.getStdinData() );
System.out.print( cl.getStderrData() );

OutputStream os = null;
try {
os = new FileOutputStream(nomearquivo);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
    OutputStreamWriter osw = new OutputStreamWriter(os);
    BufferedWriter bw = new BufferedWriter(osw);

    try {
    bw.write(cl.getStdinData() );
    bw.write(cl.getStderrData() );
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 
    try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}




}

}


package Cap2;

public class Begginer {

public static void main(String[] args) {
// TODO Auto-generated method stub

MyRun3 myrun3 = new MyRun3();

while (true) {
myrun3.executeCommand();


for (int i = 0; i < 300 ; i++) {


try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}



}
}
}

}

Socket em Java

Abaixo duas classes em Java para conexão de socket entre servidor e cliente. As classes são resultado das aulas de Sistemas Operacionais do prof Alessandro Brawerman. Na época em que pesquisei a respeito não encontrei nada tão simples e tão didático. Quando falamos em socket geralemente é acompanhado de estruturas complexas, mas abaixo as classes são simples. Deve ser configurada apenas a porta e o ip das máquinas.

import java.io.*;

import java.net.*;

import javax.swing.GroupLayout.ParallelGroup;

public class servidor {

public static void main(String args[]) throws IOException {

int porta = 10000;

Socket sock = null;

int porta2 = 10000;

String IP = "172.23.96.200";

BufferedReader teclado;

ServerSocket ss = new ServerSocket(porta2);

sock = ss.accept();

DataInputStream in = new DataInputStream(sock.getInputStream());

DataOutputStream out = new DataOutputStream(sock.getOutputStream());

//primeira msg do servidor

while (true) {

teclado = new BufferedReader(new InputStreamReader(System.in));

String texto = teclado.readLine();

out.writeUTF(texto);

System.out.println(in.readUTF());

if(texto.equals("terminar")){

break;

}

}

in.close();

out.close();

sock.close();

}

}

import java.io.*;

import java.net.*;

import java.util.Scanner;

public class cliente {

/**

 * @param args

 * @throws IOException

 */

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

int porta = 12345;

String IP="172.23.96.73";

BufferedReader teclado;

Socket sock = new Socket(IP,porta);

DataInputStream in = new DataInputStream(sock.getInputStream());

DataOutputStream out = new DataOutputStream(sock.getOutputStream());

System.out.println(in.readUTF());

teclado = new BufferedReader(new InputStreamReader(System.in));

String texto = teclado.readLine();

out.writeUTF(texto);

if (texto.equals("terminar")) {

in.close();

out.close();

sock.close();

}

}

}

Busca Recursiva no Linux

Na busca por uma palavra chave de forma recursiva tive algumas dificuldades em encontrar um arquivo. Procurando por soluções de grep encontrei uma variação com comando find que funciona bem. O grep simples não retornou o resultado que eu esperava por uma questão de case sensitive que não utilizei na primeira busca.




Comandos:


find . -type f -exec grep -l "string" {} +


find . -type f -exec grep -l "p_deleterole" {} +


Com ignore case:

find . -type f -exec grep -li "ComBOBOx" {} +



Mais tarde testando apenas o grep:

grep -ri "word" .


Com opção para exibir o número da linha:

grep -ri "word" . -n