-
Notifications
You must be signed in to change notification settings - Fork 0
/
Monitoring.java
175 lines (147 loc) · 5.49 KB
/
Monitoring.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
/*
* Project: FortisIT Bewerbung
* Author: Daniel Fahl
*/
import java.io.*;
import java.util.*;
import java.text.*;
import org.apache.http.client.*;
import org.apache.http.client.methods.*;
import org.apache.http.impl.client.*;
/**
* This class monitors a web server by checking the HTTP status code every
* 30 seconds. The URL can be entered at run time. Monitoring runs
* until any input is received / the enter key is pressed.
* Since it uses the HTTP status codes, you could further specify the
* logging output, e.g. distinguish 500-Server Error from 404-Not Found.
* It is run from the command line.
*
* Be careful with multithreading, since the logging method is not
* thread-safe!
*/
public class Monitoring implements Runnable {
volatile boolean running = true;
static String url = "http://www.example.org/";
static String logfile = "Monitoring.log";
public static void main( String[] args ) {
InputStreamReader isr = new InputStreamReader( System.in );
BufferedReader br = new BufferedReader( isr );
// Read the URL that needs to be monitored
System.out.println("Bitte geben Sie die zu überwachende URL ein und bestätigen Ihre Eingabe mit der Enter-Taste!");
try{
url = br.readLine();
} catch( IOException e ) {
System.out.println("Fehler beim Einlesen der URL. Bitte versuchen Sie es erneut!");
System.exit(1);
}
System.out.println( url + " wird überwacht, drücken Sie die Eingabetaste um das Programm zu beenden..." );
// Start monitoring the URL in another thread
Monitoring monitor = new Monitoring();
Thread t = new Thread( monitor );
t.start();
// Check for user input in this thread
Scanner scanner = new Scanner(System.in);
while( !scanner.hasNext() ) {
// do nothing, wait for input...
}
// Stop execution on input
monitor.running = false;
t.interrupt();
// cleanly close all streams
try {
isr.close();
br.close();
} catch( Exception e ) {
// DO NOTHING
}
}
/**
* This method contains the actual URL request.
* Here you could add further control over the response codes.
*/
public void run() {
while( running ) {
int statuscode = getHttpStatusCode( url );
String loggingLine;
if( statuscode >= 200 && statuscode < 300 ) {
loggingLine = getCurrentTimeString() + " : " + url + " -> erreichbar!";
} else {
loggingLine = getCurrentTimeString() + " : " + url + " -> nicht erreichbar!";
}
//System.out.println( loggingLine );
logToFile( loggingLine, logfile );
try {
Thread.sleep( 30000 );
} catch (InterruptedException e) {
// DO NOTHING
}
}
}
/**
* This method executes a HTTP-GET request and returns the HTTP status code
* (like "404-Not Found" or "500-Internal Server Error") as a numeric value.
* It does not natively support HTTP-POST or setting custom header fields.
* If anything goes wrong with this request, it returns -1.
* @param url - the URL that needs to be requested
* @return the HTTP status code
*/
public int getHttpStatusCode( String url ) {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpGet httpget = new HttpGet( url );
CloseableHttpResponse response = null;
int statuscode = -1;
try {
response = httpclient.execute( httpget );
statuscode = response.getStatusLine().getStatusCode();
} catch( Exception e ) {
e.printStackTrace();
} finally {
try {
httpclient.close();
response.close();
} catch( Exception e ) {
// DO NOTHING
}
}
return statuscode;
}
/**
* The method <code>logToFile</code> takes a String parameter containing
* a line of logging information and appends it to a filename given as
* the second parameter.
* If the file does not exist, it is created in the current working
* directory. If it does exist, the content is appended to it.
* @param line - the text that needs to be logged
* @param filename - the name of the log file
*/
public void logToFile( String line, String filename ){
BufferedWriter out = null;
try {
File dir = new File(".");
String filepath = dir.getCanonicalPath() + File.separator + filename;
FileWriter fstream = new FileWriter(filepath, true);
out = new BufferedWriter(fstream);
out.write( line );
out.newLine();
} catch( IOException e ) {
System.out.println("Die Log-Ausgabe ist fehlgeschlagen.");
} finally {
//close buffer writer
try {
out.close();
} catch( Exception e ) {
// Do nothing
}
}
}
/**
* This method returns the current time as a String of the format
* "dd-MMM-yyyy HH:mm:ss".
* @return a String representation of the current time
*/
public String getCurrentTimeString() {
SimpleDateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss");
Date now = new Date();
return sdf.format( now );
}
}