1 /*
2 * PROJECT : DAR Runtime and Tools
3 * COPYRIGHT : Copyright (C) 1999-2004 tim.stephenson@enableit.org
4 * LICENSE : GNU LESSER GENERAL PUBLIC LICENSE
5 * Version 2.1, February 1999
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 package org.enableit.db.darrt;
22
23 import java.beans.PropertyDescriptor;
24 import java.io.PrintWriter;
25 import java.io.StringWriter;
26 import java.io.Writer;
27 import java.util.Iterator;
28 import java.util.List;
29
30 import org.apache.commons.beanutils.PropertyUtils;
31 import org.apache.log4j.Logger;
32 import org.enableit.db.beans.Provider;
33 import org.enableit.db.darrt.beans.DiffData;
34
35
36 /***
37 * @author default
38 */
39 public class PlainFormatter implements DiffFormatter, ReportListener {
40 private static final String indent = " ";
41
42 /***
43 * The Log4J <code>Logger</code> doing the logging.
44 */
45 protected static Logger logger = Logger.getLogger(PlainFormatter.class);
46
47 /***
48 * The database provider to pass to the DDLFactory.
49 */
50 private Provider provider;
51
52 /***
53 * Factory for Data Definition Language.
54 */
55 private DDLFactory ddlFactory = DDLFactory.getInstance();
56 private int index = 0;
57 private PrintWriter out;
58
59 /***
60 * Default constructor.
61 * <p>Required for dynamic instantiation, but provider <em>MUST</em> be
62 * set before the formatter meay be used.</p>
63 */
64 public PlainFormatter() {
65
66 }
67
68 /***
69 * Constructor that also sets database provider.
70 */
71 public PlainFormatter(Provider provider) {
72 this.provider = provider;
73 }
74
75 /*** @param event */
76 public void handle(DarrtEvent event) {
77 switch (event.getEventId()) {
78 case DarrtEvent.START_SCHEMA_DIFF:
79 out.println("Starting schema diff between databases: "
80 + (String) event.getEventBean());
81
82 break;
83 case DarrtEvent.DIFFERENCE:
84
85 Object obj = event.getEventBean();
86 out.println(format((DiffData) obj));
87
88 break;
89 case DarrtEvent.END_SCHEMA_DIFF:
90 out.println("Completed schema diff between databases: "
91 + (String) event.getEventBean());
92
93 break;
94 case DarrtEvent.START_ALTER_SCHEMA:
95 out.println("Starting schema alterations to database: "
96 + (String) event.getEventBean());
97
98 break;
99 case DarrtEvent.SCHEMA_MODIFICATION:
100 out.println(
101 "Modifying schema to resolve the following difference: ");
102 out.println(format((DiffData) event.getEventBean()));
103
104 break;
105 case DarrtEvent.END_ALTER_SCHEMA:
106 out.println("Completed schema alterations to database: "
107 + (String) event.getEventBean());
108
109 break;
110 default:}
111
112 out.flush();
113 }
114
115 /***
116 * Set the writer for the report.
117 */
118 public void setWriter(Writer out) {
119 this.out = new PrintWriter(out);
120 }
121
122 /***
123 * Formats the differences and writes them to the writer provided.
124 *
125 * @param diffsList
126 * @param out
127 */
128 public void writeDiffs(java.util.List diffsList, java.io.Writer writer) {
129 logger.info("METHOD_ENTRY: writeDiffs");
130
131 PrintWriter out = new PrintWriter(writer);
132
133 for (Iterator i = diffsList.iterator(); i.hasNext();) {
134 DiffData diff = (DiffData) i.next();
135
136 out.println(format(diff));
137 }
138
139 out.close();
140 out = null;
141
142 logger.info("METHOD_EXIT: writeDiffs");
143 }
144
145 /***
146 * Format a difference for another class to control the writing of.
147 *
148 * @param diffData bean containing the differences.
149 */
150 public String format(DiffData diff)
151 throws ConfigurationException {
152 logger.info("METHOD_ENTRY: format");
153
154 StringWriter sw = new StringWriter();
155 PrintWriter out = new PrintWriter(sw);
156
157 out.print(++index + ". OBJECT NAME: " + diff.getName());
158 out.println(", OBJECT TYPE: " + diff.getType());
159
160 List ddlList = null;
161
162 DDLGenerator gen = ddlFactory.getGenerator(provider) ;
163 if (diff.getTargetObj() == null) {
164 out.println(indent + "Missing from target.");
165
166 out.println(indent + "Create script:");
167 ddlList = gen.getCreate(diff.getRefObj());
168 } else {
169 out.println(indent + "Reference:");
170 writeObj(diff.getRefObj(), diff.getTargetObj(), out, 0);
171
172 out.println(indent + "Target:");
173 writeObj(diff.getRefObj(), diff.getTargetObj(), out, 1);
174
175 out.println(indent + "Modify script:");
176 ddlList = gen.getModify(diff);
177 }
178
179 for (Iterator i = ddlList.iterator(); i.hasNext();) {
180 out.println(i.next());
181 }
182
183 // Make sure everything flushed
184 out.close();
185
186 logger.info("METHOD_EXIT: format");
187
188 return sw.toString();
189 }
190
191 /***
192 * Uses introspection to compare properties of reference and target objects,
193 * then write the value of the requested one the writer.
194 */
195 private void writeObj(Object refObj, Object targetObj, PrintWriter out,
196 int printObjIdx) {
197 logger.info("METHOD_ENTRY: writeObj");
198
199 String prop = null;
200
201 try {
202 PropertyDescriptor[] descriptors = PropertyUtils
203 .getPropertyDescriptors(refObj);
204
205 for (int i = 0; i < descriptors.length; i++) {
206 PropertyDescriptor descriptor = descriptors[i];
207
208 prop = descriptor.getName();
209
210 Object refProp = PropertyUtils.getProperty(refObj, prop);
211 Object targetProp = PropertyUtils.getProperty(targetObj,
212 descriptor.getName());
213
214 if ((refProp != null) && !refProp.equals(targetProp)) {
215 switch (printObjIdx) {
216 case 0:
217 out.println(indent + indent + descriptor.getName()
218 + ":" + refProp);
219
220 break;
221 case 1:
222 out.println(indent + indent + descriptor.getName()
223 + ":" + targetProp);
224
225 break;
226 }
227 }
228 }
229 } catch (Exception e) {
230 logger.error("Error occurred handling property=" + prop);
231 logger.error(e);
232 out.println("Error: no details of differences available");
233 }
234
235 logger.info("METHOD_EXIT: writeObj");
236 }
237
238 /***
239 * @return The provider for which to generate DDL from reported differences.
240 */
241 public Provider getProvider() {
242 return provider;
243 }
244
245 /***
246 * @param provider The provider for which to generate DDL from
247 * reported differences.
248 */
249 public void setProvider(Provider provider) {
250 this.provider = provider;
251 }
252
253 }
This page was automatically generated by Maven