logger.error(
                        problem.getMessage(),
                        request.isShowErrors()
                                ? problem.getException()
                                : problem.getException().getMessage());
            }
        }

        DefaultMirrorSelector mirrorSelector = new DefaultMirrorSelector();
        for (Mirror mirror : request.getMirrors()) {

                                "Failed to process POM for " + artifact.getId() + ": " + missingParentPom.getMessage(),
                                missingParentPom.getException(),
                                artifact);
                    }

                    String message;

                    if (isMissingPom(e)) {

    String getLocation();

    /**
     * Gets the exception that caused this problem (if any).
     *
     * @return The exception that caused this problem or {@code null} if not applicable.
     */
    Exception getException();

    /**
     * Gets the message that describes this problem.
     *
     * @return The message describing this problem, never {@code null}.
     */
    String getMessage();

    /**

            } catch (ModelBuildingException e) {
                for (ModelProblem problem : e.getProblems()) {
                    if (problem.getException() instanceof UnresolvableModelException) {
                        result.addException(problem.getException());
                        throw new ArtifactDescriptorException(result);
                    }
                }

                buffer.append(", ");
            }
            buffer.append("column ").append(getColumnNumber());
        }

        return buffer.toString();
    }

    public Exception getException() {
        return exception;
    }

    public String getMessage() {
        String msg;

        if (message != null && !message.isEmpty()) {
            msg = message;
        } else {

                versionIndex.put(version, workspace.getRepository());
            }
        }

        for (MetadataResult metadataResult : metadataResults) {
            result.addException(metadataResult.getException());

            ArtifactRepository repository = metadataResult.getRequest().getRepository();
            if (repository == null) {
                repository = session.getLocalRepository();
            }

                problem.getSource(),
                problem.getLineNumber(),
                problem.getColumnNumber(),
                problem.getException());
    }

            if (!location.isEmpty()) {
                message += " @ " + location;
            }

            return handle(message, problem.getException());
        } else {
            return null;
        }
    }

    private String getReference(Set<Throwable> dejaVu, Throwable exception) {
        String reference = "";

         */
        public NetbiosAddress[] getAnswer () {
            return this.ans;
        }


        /**
         * @return the uhe
         */
        public UnknownHostException getException () {
            return this.uhe;
        }

    }


    NetbiosAddress[] lookupServerOrWorkgroup ( String name, InetAddress svr ) throws UnknownHostException {
        Sem sem = new Sem(2);

                    if (logger.isDebugEnabled()) {
                        for (SettingsProblem problem : result.getProblems()) {
                            logger.debug(problem.getMessage(), problem.getException());
                        }
                    }

                    Authentication authentication = new Authentication(server.getUsername(), server.getPassword());