Source code

001/**
002 * Copyright 2010-2014 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.kuali.common.util;
017
018import java.util.ArrayList;
019import java.util.List;
020import java.util.Properties;
021
022import org.apache.commons.lang3.StringUtils;
023import org.kuali.common.util.nullify.NullUtils;
024import org.kuali.common.util.obscure.DefaultObscurer;
025import org.kuali.common.util.obscure.Obscurer;
026import org.kuali.common.util.property.Constants;
027import org.slf4j.Logger;
028import org.slf4j.LoggerFactory;
029import org.springframework.util.PropertyPlaceholderHelper;
030
031/**
032 * @deprecated
033 */
034@Deprecated
035public class LoggerUtils {
036
037        public static final Logger LOGGER_UTILS_LOGGER = LoggerFactory.getLogger(LoggerUtils.class);
038        private static final Obscurer DEFAULT_OBSCURER = new DefaultObscurer();
039        private static final PropertyPlaceholderHelper HELPER = Constants.DEFAULT_PROPERTY_PLACEHOLDER_HELPER;
040
041        public static String getLogMsg(List<String> includes, List<String> excludes) {
042                if (CollectionUtils.isEmpty(includes) && CollectionUtils.isEmpty(excludes)) {
043                        return "";
044                }
045                String includesCSV = StringUtils.trimToNull(CollectionUtils.getSpaceSeparatedCSV(includes));
046                String excludesCSV = StringUtils.trimToNull(CollectionUtils.getSpaceSeparatedCSV(excludes));
047                List<KeyValue> msgs = new ArrayList<KeyValue>();
048                if (!StringUtils.isBlank(includesCSV)) {
049                        msgs.add(new KeyValue("includes", includesCSV));
050                }
051                if (!StringUtils.isBlank(excludesCSV)) {
052                        msgs.add(new KeyValue("excludes", excludesCSV));
053                }
054                StringBuilder sb = new StringBuilder();
055                sb.append("[");
056                for (int i = 0; i < msgs.size(); i++) {
057                        if (i != 0) {
058                                sb.append("  ");
059                        }
060                        KeyValue msg = msgs.get(i);
061                        sb.append(msg.getKey());
062                        sb.append(": ");
063                        sb.append(msg.getValue());
064                }
065                sb.append("]");
066                return sb.toString();
067        }
068
069        public static String getLogMsg(StringFilter filter) {
070                Assert.notNull(filter, "filter is null");
071                return getLogMsg(filter.getIncludes(), filter.getExcludes());
072        }
073
074        public static Object[] getLogMsgArgs(StringFilter filter) {
075                Assert.notNull(filter, "filter is null");
076                String includes = CollectionUtils.getSpaceSeparatedCSV(filter.getIncludes());
077                String excludes = CollectionUtils.getSpaceSeparatedCSV(filter.getExcludes());
078                return new Object[] { includes, excludes };
079        }
080
081        public static void log(LogMsg msg, Logger logger) {
082                Assert.notNull(msg.getLevel(), "level is null");
083                Assert.notNull(logger, "logger is null");
084                logMsg(msg.getMessage(), msg.getArgs(), logger, msg.getLevel());
085        }
086
087        public static int[] getPadding(List<String> columns, List<Object[]> argsList) {
088                int[] padding = new int[columns.size()];
089                for (int i = 0; i < padding.length; i++) {
090                        padding[i] = Math.max(padding[i], columns.get(i).length());
091                }
092                for (Object[] args : argsList) {
093                        Assert.isTrue(columns.size() == args.length, "Column count must equals args.length");
094                        for (int i = 0; i < args.length; i++) {
095                                padding[i] = Math.max(padding[i], args[i].toString().length());
096                        }
097                }
098                return padding;
099        }
100
101        public static String getHeader(List<String> columns, int[] padding, boolean leftAlign) {
102                StringBuilder sb = new StringBuilder();
103                for (int i = 0; i < columns.size(); i++) {
104                        if (i == 0) {
105                                sb.append("||  ");
106                        } else {
107                                sb.append("|  ");
108                        }
109                        if (leftAlign) {
110                                sb.append(StringUtils.rightPad(columns.get(i), padding[i]));
111                        } else {
112                                sb.append(StringUtils.leftPad(columns.get(i), padding[i]));
113                        }
114                        if (i == columns.size() - 1) {
115                                sb.append("  ||");
116                        } else {
117                                sb.append("  |");
118                        }
119                }
120                return sb.toString();
121        }
122
123        public static void updateArgsList(List<Object[]> argsList, int[] padding, boolean leftAlign) {
124                for (Object[] args : argsList) {
125                        for (int i = 0; i < args.length; i++) {
126                                if (leftAlign) {
127                                        args[i] = StringUtils.rightPad(args[i].toString(), padding[i]);
128                                } else {
129                                        args[i] = StringUtils.leftPad(args[i].toString(), padding[i]);
130                                }
131                        }
132                }
133        }
134
135        public static void logTable(List<String> columns, List<Object[]> rows, LoggerLevel level, Logger logger) {
136                logTable(columns, rows, level, logger, false);
137        }
138
139        public static void logTable(List<String> columns, List<Object[]> rows, LoggerLevel level, Logger logger, boolean leftAlign) {
140                LogTableContext context = new LogTableContext();
141                context.setColumns(columns);
142                context.setRows(rows);
143                context.setLevel(level);
144                context.setLogger(logger);
145                context.setLeftAlign(leftAlign);
146
147                logTable(context);
148        }
149
150        public static void logTable(List<String> columns, List<Object[]> rows) {
151                LogTableContext context = new LogTableContext(columns, rows);
152                logTable(context);
153        }
154
155        public static String getTable(LogTableContext context) {
156                Assert.notNull(context, "context is null");
157                Assert.notNull(context.getColumns(), "columns is null");
158                Assert.notNull(context.getRows(), "rows is null");
159                int[] padding = getPadding(context.getColumns(), context.getRows());
160                int cols = context.getColumns().size();
161                int rows = context.getRows().size();
162
163                String header = getHeader(context.getColumns(), padding, context.isLeftAlign());
164                updateArgsList(context.getRows(), padding, context.isLeftAlign());
165                Properties properties = getProperties(context.getRows());
166                String tableString = getTableString(rows, cols);
167
168                String resolved = HELPER.replacePlaceholders(tableString, properties);
169
170                return header + "\n" + resolved;
171        }
172
173        public static void logTable(LogTableContext context) {
174
175                String table = getTable(context);
176
177                Assert.notNull(context.getLogger(), "logger is null");
178                Assert.notNull(context.getLevel(), "level is null");
179
180                String msg = context.getTitle() + "\n\n" + table;
181
182                logMsg(msg, context.getLogger(), context.getLevel());
183
184        }
185
186        protected static String getTableString(int rows, int cols) {
187                StringBuilder sb = new StringBuilder();
188                for (int row = 0; row < rows; row++) {
189                        for (int col = 0; col < cols; col++) {
190                                sb.append("${" + getPropertyKey(row, col) + "}");
191                        }
192                        sb.append("\n");
193                }
194                return sb.toString();
195        }
196
197        protected static Properties getProperties(List<Object[]> rows) {
198                Properties properties = new Properties();
199                for (int row = 0; row < rows.size(); row++) {
200                        Object[] rowData = rows.get(row);
201                        for (int col = 0; col < rowData.length; col++) {
202                                String key = getPropertyKey(row, col);
203                                StringBuilder sb = new StringBuilder();
204                                if (col == 0) {
205                                        sb.append("||  ");
206                                } else {
207                                        sb.append("|  ");
208                                }
209                                sb.append(rowData[col] + "");
210                                if (col == rowData.length - 1) {
211                                        sb.append("  ||");
212                                } else {
213                                        sb.append("  |");
214                                }
215                                properties.setProperty(key, sb.toString());
216                        }
217                }
218                return properties;
219        }
220
221        protected static String getPropertyKey(int row, int col) {
222                return "log.table.row." + row + ".col." + col;
223        }
224
225        public static void logLines(String s, Logger logger, LoggerLevel level) {
226                if (s == null) {
227                        return;
228                }
229                String[] lines = StringUtils.split(s, "\n");
230                for (String line : lines) {
231                        LoggerUtils.logMsg(line, logger, level);
232                }
233        }
234
235        public static final void logMsg(String msg, Object[] args, Logger logger, LoggerLevel level) {
236                switch (level) {
237                case DEBUG:
238                        logger.debug(msg, args);
239                        return;
240                case TRACE:
241                        logger.trace(msg, args);
242                        return;
243                case INFO:
244                        logger.info(msg, args);
245                        return;
246                case WARN:
247                        logger.warn(msg, args);
248                        return;
249                case ERROR:
250                        logger.error(msg, args);
251                        return;
252                default:
253                        throw new IllegalArgumentException("Logger level " + level + " is unknown");
254                }
255        }
256
257        public static final void logMsg(String msg, Logger logger, LoggerLevel level) {
258                logMsg(msg, null, logger, level);
259        }
260
261        public static final String getUsername(String username) {
262                return getNullAsNone(username);
263        }
264
265        public static final String getNullAsNone(String string) {
266                if (string == null) {
267                        return NullUtils.NONE;
268                } else {
269                        return string;
270                }
271        }
272
273        public static final String getPassword(String username, String password) {
274                return getPassword(username, password, DEFAULT_OBSCURER);
275        }
276
277        public static boolean isNullOrNone(String s) {
278                return NullUtils.isNullOrNone(s);
279        }
280
281        public static final String getPassword(String username, String password, Obscurer obscurer) {
282                if (isNullOrNone(password)) {
283                        // There is no password, return NONE
284                        return NullUtils.NONE;
285                } else if (StringUtils.equals(username, password)) {
286                        // Not exactly high security, display the clear text value
287                        return password;
288                } else {
289                        // Otherwise obscure it
290                        return obscurer.obscure(password);
291                }
292        }
293
294}