Example usage for org.apache.commons.net.ftp FTPClient disconnect

List of usage examples for org.apache.commons.net.ftp FTPClient disconnect

Introduction

In this page you can find the example usage for org.apache.commons.net.ftp FTPClient disconnect.

Prototype

@Override
public void disconnect() throws IOException 

Source Link

Document

Closes the connection to the FTP server and restores connection parameters to the default values.

Usage

From source file:org.eclipse.datatools.connectivity.sample.ftp.internal.FtpContentProvider.java

public Object[] getChildren(Object parent) {
    try {//from www . ja v  a 2s .c  om
        if (parent instanceof FTPClientObject) {
            FTPClient ftpClient = ((FTPClientObject) parent).getFtpClient();
            if (ftpClient.isConnected()) {
                FTPListParseEngine engine = ftpClient.initiateListParsing();
                FTPFile[] files = engine.getFiles();
                return FTPFileObject.convert(parent, ((FTPClientObject) parent).getProfile(), files);
            }
        } else if (parent instanceof FTPFileObject) {
            FTPFile ftpFile = ((FTPFileObject) parent).getFTPFile();
            FTPClient ftpClient = getFTPClient(parent);
            if (ftpFile.isDirectory() && ftpClient.isConnected()) {
                FTPListParseEngine engine = ftpClient.initiateListParsing(getDirectory((FTPFileObject) parent));
                FTPFile[] files = engine.getFiles();
                return FTPFileObject.convert(parent, ((FTPFileObject) parent).getProfile(), files);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        FTPClient ftpClient = getFTPClient(parent);
        try {
            if (ftpClient != null)
                ftpClient.disconnect();
        } catch (Exception ex) {
        }
    }
    return new Object[0];
}

From source file:org.ecoinformatics.datamanager.download.DownloadHandler.java

/**
 * Gets content from given source and writes it to DataStorageInterface 
 * to store them. This method will be called by run()
 * /*ww  w .ja  v  a  2  s.  c o  m*/
 * @param resourceName  the URL to the source data to be retrieved
 */
protected boolean getContentFromSource(String resourceName) {
    boolean successFlag = false;
    QualityCheck onlineURLsQualityCheck = null;
    boolean onlineURLsException = false; // used to determine status of onlineURLs quality check

    if (resourceName != null) {
        resourceName = resourceName.trim();
    }

    if (resourceName != null && (resourceName.startsWith("http://") || resourceName.startsWith("https://")
            || resourceName.startsWith("file://") || resourceName.startsWith("ftp://"))) {
        // get the data from a URL
        int responseCode = 0;
        String responseMessage = null;

        try {
            URL url = new URL(resourceName);
            boolean isFTP = false;

            if (entity != null) {
                String contentType = null;

                // Find the right MIME type and set it as content type
                if (resourceName.startsWith("http")) {
                    HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                    httpURLConnection.setRequestMethod("HEAD");
                    httpURLConnection.connect();
                    contentType = httpURLConnection.getContentType();
                    responseCode = httpURLConnection.getResponseCode();
                    responseMessage = httpURLConnection.getResponseMessage();
                } else if (resourceName.startsWith("file")) {
                    URLConnection urlConnection = url.openConnection();
                    urlConnection.connect();
                    contentType = urlConnection.getContentType();
                } else { // FTP
                    isFTP = true;
                    contentType = "application/octet-stream";
                }

                entity.setUrlContentType(contentType);
            }

            if (!isFTP) { // HTTP(S) or FILE
                InputStream filestream = url.openStream();

                try {
                    successFlag = this.writeRemoteInputStreamIntoDataStorage(filestream);
                } catch (IOException e) {
                    exception = e;
                    String errorMessage = e.getMessage();
                    if (errorMessage.startsWith(ONLINE_URLS_EXCEPTION_MESSAGE)) {
                        onlineURLsException = true;
                    }
                } finally {
                    filestream.close();
                }
            } else { // FTP
                String[] urlParts = resourceName.split("/");
                String address = urlParts[2];
                String dir = "/";
                for (int i = 3; i < urlParts.length - 1; i++) {
                    dir += urlParts[i] + "/";
                }
                String fileName = urlParts[urlParts.length - 1];
                FTPClient ftpClient = new FTPClient();
                ftpClient.connect(address);
                ftpClient.login(ANONYMOUS, anonymousFtpPasswd);
                ftpClient.changeWorkingDirectory(dir);
                ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
                ftpClient.enterLocalPassiveMode(); // necessary to avoid firewall blocking
                InputStream filestream = ftpClient.retrieveFileStream(fileName);
                try {
                    successFlag = this.writeRemoteInputStreamIntoDataStorage(filestream);
                } catch (IOException e) {
                    exception = e;
                    String errorMessage = e.getMessage();
                    if (errorMessage.startsWith(ONLINE_URLS_EXCEPTION_MESSAGE)) {
                        onlineURLsException = true;
                    }
                } finally {
                    try {
                        filestream.close();
                    } catch (IOException e) {
                        exception = new DataSourceNotFoundException(String
                                .format("Error closing local file '%s': %s", resourceName, e.getMessage()));
                        onlineURLsException = true;
                    }
                }

                // logout and disconnect if FTP session
                if (resourceName.startsWith("ftp") && ftpClient != null) {
                    try {
                        ftpClient.enterLocalActiveMode();
                        ftpClient.logout();
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        exception = new DataSourceNotFoundException(
                                String.format("Error disconnecting from FTP with resource '%s': %s",
                                        resourceName, e.getMessage()));
                        onlineURLsException = true;
                    }
                }
            }
        } catch (MalformedURLException e) {
            String eClassName = e.getClass().getName();
            String eMessage = String.format("%s: %s", eClassName, e.getMessage());
            exception = new DataSourceNotFoundException(
                    String.format("The URL '%s' is a malformed URL: %s", resourceName, eMessage));
        } catch (IOException e) {
            String eClassName = e.getClass().getName();
            String eMessage = String.format("%s: %s", eClassName, e.getMessage());
            if (responseCode > 0) {
                eMessage = String.format("Response Code: %d %s; %s", responseCode, responseMessage, eMessage);
            }
            exception = new DataSourceNotFoundException(
                    String.format("The URL '%s' is not reachable: %s", resourceName, eMessage));
        }

        // Initialize the "Online URLs are live" quality check
        String qualityCheckIdentifier = "onlineURLs";
        QualityCheck qualityCheckTemplate = QualityReport.getQualityCheckTemplate(qualityCheckIdentifier);
        onlineURLsQualityCheck = new QualityCheck(qualityCheckIdentifier, qualityCheckTemplate);

        if (QualityCheck.shouldRunQualityCheck(entity, onlineURLsQualityCheck)) {
            String resourceNameEscaped = embedInCDATA(resourceName);

            if (!onlineURLsException) {
                onlineURLsQualityCheck.setStatus(Status.valid);
                onlineURLsQualityCheck.setFound("true");
                onlineURLsQualityCheck.setExplanation("Succeeded in accessing URL: " + resourceNameEscaped);
            } else {
                onlineURLsQualityCheck.setFailedStatus();
                onlineURLsQualityCheck.setFound("false");
                String explanation = "Failed to access URL: " + resourceNameEscaped;
                explanation = explanation + "; " + embedInCDATA(exception.getMessage());
                onlineURLsQualityCheck.setExplanation(explanation);
            }

            entity.addQualityCheck(onlineURLsQualityCheck);
        }

        return successFlag;
    } else if (resourceName != null && resourceName.startsWith("ecogrid://")) {
        // get the docid from url
        int start = resourceName.indexOf("/", 11) + 1;
        //log.debug("start: " + start);
        int end = resourceName.indexOf("/", start);

        if (end == -1) {
            end = resourceName.length();
        }

        //log.debug("end: " + end);
        String ecogridIdentifier = resourceName.substring(start, end);
        // pass this docid and get data item
        //System.out.println("the endpoint is "+ECOGRIDENDPOINT);
        //System.out.println("The identifier is "+ecogridIdentifier);
        //return false;
        return getContentFromEcoGridSource(ecogridEndPoint, ecogridIdentifier);
    } else if (resourceName != null && resourceName.startsWith("srb://")) {
        // get srb docid from the url
        String srbIdentifier = transformSRBurlToDocid(resourceName);
        // reset endpoint for srb (This is hack we need to figure ou
        // elegent way to do this
        //mEndPoint = Config.getValue("//ecogridService/srb/endPoint");
        // pass this docid and get data item
        //log.debug("before get srb data");
        return getContentFromEcoGridSource(SRBENDPOINT, srbIdentifier);
    } else {
        successFlag = false;
        return successFlag;
    }
}

From source file:org.geon.XMLToADN.java

private String process(String xmlString) {

    Map metadata = new HashMap();

    // Extracting user input (name/value pairs) into a hashmap.
    int nameStartInd = xmlString.toLowerCase().indexOf("<name>");
    while (nameStartInd != -1) {
        int nameEndInd = xmlString.toLowerCase().indexOf("</name>");
        String name = xmlString.substring(nameStartInd + 6, nameEndInd);
        xmlString = xmlString.substring(nameEndInd + 7);
        int valueStartInd = xmlString.toLowerCase().indexOf("<value>");
        int valueEndInd = xmlString.toLowerCase().indexOf("</value>");
        String value = xmlString.substring(valueStartInd + 7, valueEndInd);
        xmlString = xmlString.substring(valueEndInd + 8);
        metadata.put(name, value);// ww  w . j  av  a 2s . c  o  m
        nameStartInd = xmlString.toLowerCase().indexOf("<name>");
    }

    String errMsg = "";

    String title = (String) metadata.get("title");
    String subjectss = (String) metadata.get("subjects");
    String keywords = (String) metadata.get("keywords");
    String permission = (String) metadata.get("permission");
    String description = (String) metadata.get("description");

    String personOrOrg1 = (String) metadata.get("person1");
    String role1 = (String) metadata.get("role1");
    String nametitle1 = (String) metadata.get("nametitle1");
    String firstname1 = (String) metadata.get("firstname1");
    String middlename1 = (String) metadata.get("middlename1");
    String lastname1 = (String) metadata.get("lastname1");
    String org1 = (String) metadata.get("org1");

    String email1 = (String) metadata.get("email1");
    String homepage1 = (String) metadata.get("homepage1");

    // handle spatial coverage
    // String min_altitude = (String) metadata.get("min_altitude");
    // String max_altitude = (String) metadata.get("max_altitude");

    String hrizontal = (String) metadata.get("hrizontal");
    String projection = (String) metadata.get("projection");
    String coordinate = (String) metadata.get("coordinate");

    // handle temporal coverage
    String time = (String) metadata.get("time");

    String geologic_time = (String) metadata.get("geologic_time");
    String begin_age = (String) metadata.get("begin_age");
    String end_age = (String) metadata.get("end_age");

    // handle present coverage
    String begin_date = (String) metadata.get("begindate");
    String end_date = (String) metadata.get("enddate");

    String t = time.trim();

    StringTokenizer stb = !time.equals("present") ? null : new StringTokenizer(begin_date, "/");

    int bm = !time.equals("present") ? 0 : Integer.parseInt(stb.nextToken());
    int bd = !time.equals("present") ? 0 : Integer.parseInt(stb.nextToken());
    int by = !time.equals("present") ? 0 : Integer.parseInt(stb.nextToken());

    StringTokenizer ste = !t.equals("present") ? null : new StringTokenizer(end_date, "/");

    int em;
    if (!t.equals("present")) {
        em = 0;
    } else {
        em = Integer.parseInt(ste.nextToken());
    }

    int ed;
    if (!t.equals("present")) {
        ed = 0;
    } else {
        ed = Integer.parseInt(ste.nextToken());
    }

    int ey;
    if (!t.equals("present")) {
        ey = 0;
    } else {
        ey = Integer.parseInt(ste.nextToken());
    }

    String begin_hour = (String) metadata.get("begin_hour");
    String end_hour = (String) metadata.get("end_hour");
    String begin_min = (String) metadata.get("begin_min");
    String end_min = (String) metadata.get("end_min");
    String begin_sec = (String) metadata.get("begin_sec");
    String end_sec = (String) metadata.get("end_sec");

    int bHour = Integer.parseInt(begin_hour);
    int bMin = Integer.parseInt(begin_min);
    int bSec = Integer.parseInt(begin_sec);

    int eHour = Integer.parseInt(end_hour);
    int eMin = Integer.parseInt(end_min);
    int eSec = Integer.parseInt(end_sec);

    String begin_month;
    String begin_day;
    String begin_year;

    String end_month;
    String end_day;
    String end_year;

    boolean earlier = true;

    if ((by < ey) || (by == ey && bm < em) || (by == ey && bm == em && bd < ed)
            || (by == ey && bm == em && bd == ed && bHour < eHour)
            || (by == ey && bm == em && bd == ed && bHour == eHour && bMin < eMin)
            || (by == ey && bm == em && bd == ed && bHour == eHour && bMin == eMin && bSec <= eSec)) {

        // begin date and time is earlier
        begin_month = Integer.toString(bm);
        begin_day = Integer.toString(bd);
        begin_year = Integer.toString(by);

        end_month = Integer.toString(em);
        end_day = Integer.toString(ed);
        end_year = Integer.toString(ey);

    } else {

        earlier = false;

        begin_month = Integer.toString(em);
        begin_day = Integer.toString(ed);
        begin_year = Integer.toString(ey);

        end_month = Integer.toString(bm);
        end_day = Integer.toString(bd);
        end_year = Integer.toString(by);

        String tmp = begin_hour;
        begin_hour = end_hour;
        end_hour = tmp;

        tmp = begin_min;
        begin_min = end_min;
        end_min = tmp;

        tmp = begin_sec;
        begin_sec = end_sec;
        end_sec = tmp;

    }

    String time_choice;
    if (by >= 0 && ey >= 0) {
        time_choice = "AD";
    } else if (by < 0 && ey < 0) {
        time_choice = "BC";
    } else {
        time_choice = "direct";
    }

    String bc_begin_year = earlier ? Integer.toString(-by) : Integer.toString(-ey);
    String bc_end_year = earlier ? Integer.toString(-ey) : Integer.toString(-by);

    String d_begin_year = earlier ? Integer.toString(-by) : Integer.toString(-ey);
    String d_end_year = earlier ? Integer.toString(ey) : Integer.toString(by);

    try {
        ObjectFactory factory = new ObjectFactory();

        ADNmetadataType itemRecord = (ADNmetadataType) factory
                .newInstance(Class.forName("org.dlese.adn.ItemRecord"));

        // //////////////////////////////////////////////////////////
        // //
        // // general
        // //
        // /////////////////////////////////////////////////////////
        GeneralType general = (GeneralType) factory.newInstance(Class.forName("org.dlese.adn.GeneralType"));
        general.setTitle(title);
        general.setDescription(description);
        general.setLanguage("en");

        // subjects
        SubjectsType subjects = (SubjectsType) factory.newInstance(Class.forName("org.dlese.adn.SubjectsType"));
        general.setSubjects(subjects);
        subjects.getSubject().add(subjectss);

        // keywords
        if (keywords != null) {
            KeywordsType keywordsType = (KeywordsType) factory
                    .newInstance(Class.forName("org.dlese.adn.KeywordsType"));

            general.setKeywords(keywordsType);
            StringTokenizer st = new StringTokenizer(keywords, ",");
            while (st.hasMoreTokens()) {
                String tmp = st.nextToken().trim();
                KeywordType keyword = (KeywordType) factory
                        .newInstance(Class.forName("org.dlese.adn.KeywordType"));
                keyword.setValue(tmp);
                keywordsType.getKeyword().add(keyword);
            }
        }
        // lifecycle
        LifecycleType lifecycle = (LifecycleType) factory
                .newInstance(Class.forName("org.dlese.adn.LifecycleType"));

        // set the first contributor
        ContributorsLifecycleType contributors = (ContributorsLifecycleType) factory
                .newInstance(Class.forName("org.dlese.adn.ContributorsLifecycleType"));
        lifecycle.setContributors(contributors);

        ContributorLifecycleType author = (ContributorLifecycleType) factory
                .newInstance(Class.forName("org.dlese.adn.ContributorLifecycleType"));
        author.setRole(role1);

        if (personOrOrg1.equals("Person")) {
            PersonType person = (PersonType) factory.newInstance(Class.forName("org.dlese.adn.PersonType"));
            person.setNameTitle(nametitle1);
            person.setNameFirst(firstname1);
            person.setNameMiddle(middlename1);
            person.setNameLast(lastname1);
            person.setInstName(org1);
            person.setEmailPrimary(email1);
            author.setPerson(person);

            contributors.getContributor().add(author);
        } else {
            OrganizationType org = (OrganizationType) factory
                    .newInstance(Class.forName("org.dlese.adn.OrganizationType"));
            org.setInstName(org1);
            contributors.getContributor().add(org);
        }

        // //////////////////////////////////////////////////////////
        // //
        // // metametadata
        // //
        // /////////////////////////////////////////////////////////
        MetaMetadataType metaMetadata = (MetaMetadataType) factory
                .newInstance(Class.forName("org.dlese.adn.MetaMetadataType"));
        CatalogEntriesType catalogEntries = (CatalogEntriesType) factory
                .newInstance(Class.forName("org.dlese.adn.CatalogEntriesType"));

        CatalogType catalog = (CatalogType) factory.newInstance(Class.forName("org.dlese.adn.CatalogType"));
        catalog.setValue("shapefile");

        // get unique id
        // UUIDGenerator ug = UUIDGenerator.getInstance();
        // UUID uuid = ug.generateTimeBasedUUID();

        UUIDGen uuidgen = new UUIDGen();
        String uuid = uuidgen.generateUUID();

        catalog.setEntry("GEON-" + uuid);
        catalogEntries.getCatalog().add(catalog);
        metaMetadata.setCatalogEntries(catalogEntries);

        DateInfoType dateInfo = (DateInfoType) factory.newInstance(Class.forName("org.dlese.adn.DateInfoType"));
        Calendar now = Calendar.getInstance();
        // dateInfo.setCreated(now.get(Calendar.YEAR)+"-"+now.get(Calendar.MONTH)+"-"+now.get(Calendar.DAY_OF_MONTH));
        dateInfo.setCreated(now);
        dateInfo.setValue("Registered");
        metaMetadata.setDateInfo(dateInfo);

        StatusOfType statusOf = (StatusOfType) factory.newInstance(Class.forName("org.dlese.adn.StatusOfType"));
        statusOf.setStatus("Submitted");
        statusOf.setValue("Submitted");
        metaMetadata.setStatusOf(statusOf);

        metaMetadata.setLanguage("en");
        metaMetadata.setCopyright("No");
        metaMetadata.setScheme("No scheme");

        TermsOfUseType termsOfUse = (TermsOfUseType) factory
                .newInstance(Class.forName("org.dlese.adn.TermsOfUseType"));
        termsOfUse.setValue("Terms of use consistent with GEON policy.");
        metaMetadata.setTermsOfUse(termsOfUse);

        // //////////////////////////////////////////////////////////
        // //
        // // technical
        // //
        // /////////////////////////////////////////////////////////
        TechnicalType technical = (TechnicalType) factory
                .newInstance(Class.forName("org.dlese.adn.TechnicalType"));
        OnlineType online = (OnlineType) factory.newInstance(Class.forName("org.dlese.adn.OnlineType"));
        online.setPrimaryURL("http://www.geongrid.org");

        RequirementsType requirements = (RequirementsType) factory
                .newInstance(Class.forName("org.dlese.adn.RequirementsType"));
        online.setRequirements(requirements);

        RequirementType requirement = (RequirementType) factory
                .newInstance(Class.forName("org.dlese.adn.RequirementType"));
        requirement.setReqType("DLESE:General:No specific technical requirements");
        requirements.getRequirement().add(requirement);

        technical.setOnline(online);

        // //////////////////////////////////////////////////////////
        // //
        // // right
        // //
        // /////////////////////////////////////////////////////////
        RightsType rights = (RightsType) factory.newInstance(Class.forName("org.dlese.adn.RightsType"));

        rights.setDescription(permission);
        rights.setCost("DLESE:No");

        // //////////////////////////////////////////////////////////
        // //
        // // relation
        // //
        // /////////////////////////////////////////////////////////
        RelationsType relations = (RelationsType) factory
                .newInstance(Class.forName("org.dlese.adn.RelationsType"));

        // //////////////////////////////////////////////////////////
        // //
        // // spatial coverage
        // //
        // /////////////////////////////////////////////////////////
        GeospatialCoveragesType geospatialCoverages = (GeospatialCoveragesType) factory
                .newInstance(Class.forName("org.dlese.adn.GeospatialCoveragesType"));

        GeospatialCoverageType geospatialCoverage = (GeospatialCoverageType) factory
                .newInstance(Class.forName("org.dlese.adn.GeospatialCoverageType"));

        BodyType body = (BodyType) factory.newInstance(Class.forName("org.dlese.adn.BodyType"));
        body.setPlanet("Earth");
        geospatialCoverage.setBody(body);

        geospatialCoverage.setGeodeticDatumGlobalOrHorz(hrizontal);

        ProjectionType proj = (ProjectionType) factory
                .newInstance(Class.forName("org.dlese.adn.ProjectionType"));
        proj.setType(projection);
        proj.setValue("Some projections here");
        geospatialCoverage.setProjection(proj);

        CoordinateSystemType coord = (CoordinateSystemType) factory
                .newInstance(Class.forName("org.dlese.adn.CoordinateSystemType"));
        coord.setType(coordinate);
        coord.setValue("Some cordinate system here");
        geospatialCoverage.setCoordinateSystem(coord);

        BoundBoxType box = (BoundBoxType) factory.newInstance(Class.forName("org.dlese.adn.BoundBoxType"));
        box.setBbSrcName("Cataloger supplied");

        /*
         * VertType vert =
         * (VertType)factory.newInstance(Class.forName("org.dlese.adn.VertType"
         * )); VertMinMaxType min =
         * (VertMinMaxType)factory.newInstance(Class
         * .forName("org.dlese.adn.VertMinMaxType"));
         * min.setUnits("centimeters (cm)"); min.setValue(new
         * BigDecimal(min_altitude[0]));
         * 
         * VertMinMaxType max =
         * (VertMinMaxType)factory.newInstance(Class.forName
         * ("org.dlese.adn.VertMinMaxType"));
         * max.setUnits("centimeters (cm)"); max.setValue(new
         * BigDecimal(max_altitude[0]));
         * 
         * vert.setVertMin(min); vert.setVertMax(max);
         * vert.setGeodeticDatumGlobalOrVert("DLESE:CGD28-CDN");
         * vert.setVertBase("Datum level");
         * 
         * box.setBbVert(vert);
         */

        geospatialCoverage.setBoundBox(box);
        // geospatialCoverage.setDetGeos();

        geospatialCoverages.getGeospatialCoverage().add(geospatialCoverage);

        // //////////////////////////////////////////////////////////
        // //
        // // temporal coverage
        // //
        // /////////////////////////////////////////////////////////
        TemporalCoveragesType temporalCoverages = (TemporalCoveragesType) factory
                .newInstance(Class.forName("org.dlese.adn.TemporalCoveragesType"));
        TimeAndPeriodType timeAndPeriod = (TimeAndPeriodType) factory
                .newInstance(Class.forName("org.dlese.adn.TimeAndPeriodType"));
        temporalCoverages.getTimeAndPeriod().add(timeAndPeriod);

        // set time directly into relativeTime
        TimeInfoType timeInfo = (TimeInfoType) factory.newInstance(Class.forName("org.dlese.adn.TimeInfoType"));

        timeAndPeriod.setTimeInfo(timeInfo);

        if (time.equals("notpresent")) {
            if (geologic_time.equals("other")) {

                TimeRelativeType timeRelative = (TimeRelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.TimeRelativeType"));
                timeInfo.setTimeRelative(timeRelative);

                RelativeType begin = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setBegin(begin);
                begin.setValue(new BigDecimal(begin_age));
                begin.setUnits("ma");

                RelativeType end = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setEnd(end);
                end.setValue(new BigDecimal(end_age));
                end.setUnits("ma");

            } else {

                TimeRelativeType timeRelative = (TimeRelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.TimeRelativeType"));
                timeInfo.setTimeRelative(timeRelative);

                RelativeType begin = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setBegin(begin);
                begin.setValue(new BigDecimal(0));
                begin.setUnits("ma");

                RelativeType end = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setEnd(end);
                end.setValue(new BigDecimal(0));
                end.setUnits("ma");

                // set time to periods
                PeriodsType periods = (PeriodsType) factory
                        .newInstance(Class.forName("org.dlese.adn.PeriodsType"));
                timeAndPeriod.setPeriods(periods);

                PeriodType period = (PeriodType) factory.newInstance(Class.forName("org.dlese.adn.PeriodType"));
                periods.getPeriod().add(period);
                period.setName(geologic_time);
                period.setSource("USGS-Geologic-Time-Scale");

            }
        } else if (time.equals("present")) {

            // set time directly into timeAD or timeBC
            if (time_choice.equals("AD")) {

                TimeADType timeAD = (TimeADType) factory.newInstance(Class.forName("org.dlese.adn.TimeADType"));
                timeInfo.setTimeAD(timeAD);

                Calendar begin = Calendar.getInstance();
                begin.clear();

                begin.add(Calendar.YEAR, Integer.parseInt(begin_year) - 1970);
                begin.add(Calendar.MONTH, Integer.parseInt(begin_month) - 1);
                begin.add(Calendar.DAY_OF_MONTH, Integer.parseInt(begin_day) - 1);

                Calendar bt = Calendar.getInstance();
                bt.clear();

                bt.add(Calendar.HOUR, Integer.parseInt(begin_hour));
                bt.add(Calendar.MINUTE, Integer.parseInt(begin_min));
                bt.add(Calendar.SECOND, Integer.parseInt(begin_sec));

                Calendar end = Calendar.getInstance();
                end.clear();
                end.add(Calendar.YEAR, Integer.parseInt(end_year) - 1970);
                end.add(Calendar.MONTH, Integer.parseInt(end_month) - 1);
                end.add(Calendar.DAY_OF_MONTH, Integer.parseInt(end_day) - 1);

                Calendar et = Calendar.getInstance();
                et.clear();

                et.add(Calendar.HOUR, Integer.parseInt(end_hour));
                et.add(Calendar.MINUTE, Integer.parseInt(end_min));
                et.add(Calendar.SECOND, Integer.parseInt(end_sec));

                ADType tmp = (ADType) factory.newInstance(Class.forName("org.dlese.adn.ADType"));
                tmp.setDate(begin);
                tmp.setTime(bt);
                tmp.setValue("");
                timeAD.setBegin(tmp);

                tmp = (ADType) factory.newInstance(Class.forName("org.dlese.adn.ADType"));
                tmp.setDate(end);
                tmp.setTime(et);
                tmp.setValue("");
                timeAD.setEnd(tmp);

            } else if (time_choice.equals("BC")) {

                TimeBCType timeBC = (TimeBCType) factory.newInstance(Class.forName("org.dlese.adn.TimeBCType"));
                timeInfo.setTimeBC(timeBC);

                timeBC.setBegin(bc_begin_year);
                timeBC.setEnd(bc_end_year);

            } else if (time_choice.equals("direct")) {

                TimeRelativeType timeRelative = (TimeRelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.TimeRelativeType"));
                timeInfo.setTimeRelative(timeRelative);

                RelativeType begin = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setBegin(begin);
                begin.setValue(new BigDecimal("-" + d_begin_year));
                begin.setUnits("year");

                RelativeType end = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setEnd(end);
                end.setValue(new BigDecimal(d_end_year));
                end.setUnits("year");

            }
        }

        // handle object in space
        ObjectsInSpaceType objectsInSpace = (ObjectsInSpaceType) factory
                .newInstance(Class.forName("org.dlese.adn.ObjectsInSpaceType"));

        itemRecord.setGeneral(general);
        itemRecord.setLifecycle(lifecycle);
        itemRecord.setMetaMetadata(metaMetadata);
        itemRecord.setRights(rights);
        itemRecord.setTechnical(technical);
        // itemRecord.setRelations(relations);
        itemRecord.setGeospatialCoverages(geospatialCoverages);
        if (!time.equals("any")) {
            itemRecord.setTemporalCoverages(temporalCoverages);
        }
        itemRecord.setObjectsInSpace(objectsInSpace);

        // marshall
        JAXBContext jc = JAXBContext.newInstance("org.dlese.adn");
        Marshaller m = jc.createMarshaller();
        m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

        // create and save target

        // save into a directory
        File dir = new File("adn/" + uuid); // TODO: remove adn folder once
        // all the files have been
        // removed.
        dir.mkdirs();
        dirPath = dir.getAbsolutePath();

        // unzip the uploaded file
        String shpFile = shpURL;
        String unzipFileName = "";
        if (shpFile.trim().startsWith("http://")) {
            URL shpURL = new URL(shpFile);
            HttpURLConnection huc = (HttpURLConnection) shpURL.openConnection();
            huc.connect();
            InputStream in = huc.getInputStream();
            File zip = new File(dir, "tmp.zip");
            FileOutputStream out = new FileOutputStream(zip);
            byte[] buffer = new byte[1024];
            int count = in.read(buffer);
            while (count > 0) {
                out.write(buffer, 0, count);
                count = in.read(buffer);
            }
            huc.disconnect();
            out.close();
            unzipFileName = unzip(dir, zip); // Unzipping the ftpped file to
            // dir.
            zip.delete(); // the zip file is no longer necessary.
        } else if (shpFile.trim().startsWith("ftp://")) {
            shpFile = shpFile.substring(6);
            String username = "anonymous";
            String password = "geon@geongrid.org";
            int index = shpFile.indexOf("/");
            String hostname = shpFile.substring(0, index);
            String filename = shpFile.substring(index);
            org.apache.commons.net.ftp.FTPClient f = new org.apache.commons.net.ftp.FTPClient();
            f.connect(hostname);
            f.login(username, password);
            f.setFileType(FTP.BINARY_FILE_TYPE);
            File zip = new File(dir, "tmp.zip");
            FileOutputStream fos = new FileOutputStream(zip);
            f.retrieveFile(filename, fos);
            f.disconnect();
            fos.close();
            unzipFileName = unzip(dir, zip); // Unzipping the ftpped file to
            // dir.
            zip.delete(); // the zip file is no longer necessary.

        } else { // file is local..
            java.io.File zip = new java.io.File(shpFile);
            unzipFileName = unzip(dir, zip);
        }

        if (!unzipFileName.equals("")) {
            // calculate the binding box and set the adn schema
            shpfis = new FileInputStream(dirPath + "/" + unzipFileName + ".shp");
            Shapefile shape = new Shapefile(shpfis);
            double[] bounds = shape.getBounds();

            box.setWestCoord(new BigDecimal(bounds[0]));
            box.setNorthCoord(new BigDecimal(bounds[1]));
            box.setEastCoord(new BigDecimal(bounds[2]));
            box.setSouthCoord(new BigDecimal(bounds[3]));

            shpfis.close();
            // Object x = (Object) shape;

            // shape = new Shapefile();

            /*
             * File shp = new File(dir, unzipFileName + ".shp"); File shx =
             * new File(dir, unzipFileName + ".shx"); File dbf = new
             * File(dir, unzipFileName + ".dbf");
             * 
             * 
             * shp.delete(); shx.delete(); dbf.delete(); //dir.delete();
             */
        }
        /*
         * // calculate the schema and ask for more explanation DBase db =
         * new DBase(dirName); db.openTable(fileName); String [] columns =
         * db.getColumnNames(); ArrayList list = new ArrayList(); for (int
         * i=0; i<columns.length; i++) { list.add(columns[i]); }
         */// save its metadata
        File adn = new File(dir, uuid + ".adn");
        FileOutputStream fos = new FileOutputStream(adn);
        m.marshal(itemRecord, fos);
        fos.close();

        /*
         * } catch (Exception e) {
         * 
         * try { PrintWriter pw = new PrintWriter(new
         * FileWriter("/home/jaeger/log.txt", true)); e.printStackTrace(pw);
         * pw.flush(); } catch (Exception ex) {}
         * 
         * throw new JspException(e.getMessage()); } return SKIP_BODY; }
         * 
         * 
         * 
         * private String label(String string) { return
         * "<table width=90% cellpadding=1 cellspacing=0 border=0>\n"+
         * "<tr><td bgcolor=Gainsboro>\n"+
         * "<font face=\"arial,sans-serif\" size=-1 color=#777777>\n"+
         * "&nbsp; <b>"+string+"</b>\n"+ "</font>\n"+ "</td></tr>\n"+
         * "</table>\n"; }
         * 
         * 
         * private String message(String key, String val) { return
         * "    <tr>\n" +
         * "        <td align=right width=150><div class=label><b>"
         * +key+":</b></div></td>\n" +
         * "        <td align=left>"+val+"</td>\n" + "    </tr>\n"; }
         * 
         * 
         * private String messagePadding(String key, String val) { return
         * "    <tr>\n" +
         * "        <td align=right width=150><div class=label>&nbsp;&nbsp;&nbsp;"
         * +key+":</div></td>\n" + "        <td align=left>"+val+"</td>\n" +
         * "    </tr>\n"; }
         */
        return adn.getAbsolutePath();
    } catch (ClassNotFoundException cnfex) {
        cnfex.printStackTrace();
        _deleteFiles();
    } catch (JAXBException jex) {
        jex.printStackTrace();
        _deleteFiles();
    } catch (FileNotFoundException fnex) {
        fnex.printStackTrace();
        _deleteFiles();
    } catch (IOException ioex) {
        ioex.printStackTrace();
        _deleteFiles();
    } catch (ShapefileException shex) {
        shex.printStackTrace();
        _deleteFiles();
    } catch (Exception ex) {
        ex.printStackTrace();
        _deleteFiles();
    }
    return "";

}

From source file:org.glassfish.common.util.admin.MapInjectionResolver.java

private void FormatUriToFile() throws IOException {
    List<String> value = parameters.get("DEFAULT");
    String uri = value.get(0);/*from w w  w .  j  av  a 2s  .c  om*/
    URL url = new URL(uri);
    File file = null;

    if (uri.startsWith("file:/")) {
        file = new File(url.getFile());
    } else if (uri.startsWith("http://")) {
        InputStream inStream = url.openStream();
        BufferedInputStream bufIn = new BufferedInputStream(inStream);

        file = new File(System.getenv().get("TEMP") + uri.substring(uri.lastIndexOf("/")));
        if (file.exists()) {
            file.delete();
        }
        OutputStream out = new FileOutputStream(file);
        BufferedOutputStream bufOut = new BufferedOutputStream(out);
        byte buffer[] = new byte[204800];
        while (true) {
            int nRead = bufIn.read(buffer, 0, buffer.length);
            if (nRead <= 0)
                break;
            bufOut.write(buffer, 0, nRead);
        }
        bufOut.flush();
        out.close();
        inStream.close();
    } else if (uri.startsWith("ftp://")) {
        String pattern = "^ftp://(.+?)(:.+?)?@(\\S+):(\\d+)(\\S+)$";
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(uri);
        if (m.matches()) {
            String username = m.group(1);
            String password = "";
            if (m.group(2) != null) {
                password = m.group(2).replace(":", "");
            }
            String ipAddress = m.group(3);
            String port = m.group(4);
            String path = m.group(5);
            FTPClient ftp = new FTPClient();
            ftp.connect(ipAddress);
            ftp.setDefaultPort(Integer.parseInt(port));
            boolean isLogin = ftp.login(username, password);
            if (isLogin) {
                ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
                byte[] buf = new byte[204800];
                int bufsize = 0;

                file = new File(System.getenv().get("TEMP") + uri.substring(uri.lastIndexOf("/")));
                if (file.exists()) {
                    file.delete();
                }
                OutputStream ftpOut = new FileOutputStream(file);
                InputStream ftpIn = ftp.retrieveFileStream(path);
                System.out.println(ftpIn);
                while ((bufsize = ftpIn.read(buf, 0, buf.length)) != -1) {
                    ftpOut.write(buf, 0, bufsize);
                }
                ftpOut.flush();
                ftpOut.close();
                ftpIn.close();
            } else {
                ftp.logout();
                ftp.disconnect();
            }
        } else {
            localStrings.getLocalString("IncorrectFtpAddress",
                    "The ftp address is not correct, please change another one.");
        }
    }
    if (file != null)
        parameters.set("DEFAULT", file.getAbsolutePath());
}

From source file:org.gogpsproject.parser.rinex.RinexNavigation.java

private RinexNavigationParser getFromFTP(String url) throws IOException {
    RinexNavigationParser rnp = null;/*from w w  w.j  av a 2s  .  c  o  m*/

    String origurl = url;
    if (negativeChache.containsKey(url)) {
        if (System.currentTimeMillis() - negativeChache.get(url).getTime() < 60 * 60 * 1000) {
            throw new FileNotFoundException("cached answer");
        } else {
            negativeChache.remove(url);
        }
    }

    String filename = url.replaceAll("[ ,/:]", "_");
    if (filename.endsWith(".Z"))
        filename = filename.substring(0, filename.length() - 2);
    File rnf = new File(RNP_CACHE, filename);

    if (!rnf.exists()) {
        System.out.println(url + " from the net.");
        FTPClient ftp = new FTPClient();

        try {
            int reply;
            System.out.println("URL: " + url);
            url = url.substring("ftp://".length());
            String server = url.substring(0, url.indexOf('/'));
            String remoteFile = url.substring(url.indexOf('/'));
            String remotePath = remoteFile.substring(0, remoteFile.lastIndexOf('/'));
            remoteFile = remoteFile.substring(remoteFile.lastIndexOf('/') + 1);

            ftp.connect(server);
            ftp.login("anonymous", "info@eriadne.org");

            System.out.print(ftp.getReplyString());

            // After connection attempt, you should check the reply code to
            // verify
            // success.
            reply = ftp.getReplyCode();

            if (!FTPReply.isPositiveCompletion(reply)) {
                ftp.disconnect();
                System.err.println("FTP server refused connection.");
                return null;
            }

            System.out.println("cwd to " + remotePath + " " + ftp.changeWorkingDirectory(remotePath));
            System.out.println(ftp.getReplyString());
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
            System.out.println(ftp.getReplyString());

            System.out.println("open " + remoteFile);
            InputStream is = ftp.retrieveFileStream(remoteFile);
            InputStream uis = is;
            System.out.println(ftp.getReplyString());
            if (ftp.getReplyString().startsWith("550")) {
                negativeChache.put(origurl, new Date());
                throw new FileNotFoundException();
            }

            if (remoteFile.endsWith(".Z")) {
                uis = new UncompressInputStream(is);
            }

            rnp = new RinexNavigationParser(uis, rnf);
            rnp.init();
            is.close();

            ftp.completePendingCommand();

            ftp.logout();
        } finally {
            if (ftp.isConnected()) {
                try {
                    ftp.disconnect();
                } catch (IOException ioe) {
                    // do nothing
                }
            }
        }
    } else {
        System.out.println(url + " from cache file " + rnf);
        rnp = new RinexNavigationParser(rnf);
        rnp.init();
    }
    return rnp;
}

From source file:org.gogpsproject.parser.sp3.SP3Navigation.java

private SP3Parser getFromFTP(String url) throws IOException {
    SP3Parser sp3p = null;//  w  ww.  j ava 2  s.c  o  m

    String filename = url.replaceAll("[ ,/:]", "_");
    if (filename.endsWith(".Z"))
        filename = filename.substring(0, filename.length() - 2);
    File sp3f = new File(SP3_CACHE, filename);

    if (!sp3f.exists()) {
        System.out.println(url + " from the net.");
        FTPClient ftp = new FTPClient();

        try {
            int reply;
            System.out.println("URL: " + url);
            url = url.substring("ftp://".length());
            String server = url.substring(0, url.indexOf('/'));
            String remoteFile = url.substring(url.indexOf('/'));
            String remotePath = remoteFile.substring(0, remoteFile.lastIndexOf('/'));
            remoteFile = remoteFile.substring(remoteFile.lastIndexOf('/') + 1);

            ftp.connect(server);
            ftp.login("anonymous", "info@eriadne.org");

            System.out.print(ftp.getReplyString());

            // After connection attempt, you should check the reply code to
            // verify
            // success.
            reply = ftp.getReplyCode();

            if (!FTPReply.isPositiveCompletion(reply)) {
                ftp.disconnect();
                System.err.println("FTP server refused connection.");
                return null;
            }

            System.out.println("cwd to " + remotePath + " " + ftp.changeWorkingDirectory(remotePath));
            System.out.println(ftp.getReplyString());
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
            System.out.println(ftp.getReplyString());

            System.out.println("open " + remoteFile);
            InputStream is = ftp.retrieveFileStream(remoteFile);
            InputStream uis = is;
            System.out.println(ftp.getReplyString());
            if (ftp.getReplyString().startsWith("550")) {
                throw new FileNotFoundException();
            }

            if (remoteFile.endsWith(".Z")) {
                uis = new UncompressInputStream(is);
            }

            sp3p = new SP3Parser(uis, sp3f);
            sp3p.init();
            is.close();

            ftp.completePendingCommand();

            ftp.logout();
        } finally {
            if (ftp.isConnected()) {
                try {
                    ftp.disconnect();
                } catch (IOException ioe) {
                    // do nothing
                }
            }
        }
    } else {
        System.out.println(url + " from cache file " + sp3f);
        sp3p = new SP3Parser(sp3f);
        sp3p.init();
    }
    return sp3p;
}

From source file:org.grouter.core.readers.FtpReaderJob.java

@Override
protected List<CommandMessage> readFromSource() {
    logger.info("Reading files from :" + node.getInBound().getUri());

    // a list of full paths on ftp server we will download from
    Map endPointContext = node.getInBound().getEndPointContext();

    List<String> remoteFtpUriToFile = getPathIncludingFile((String) endPointContext.get(FILE_LIST));
    List<CommandMessage> commandMessages = new ArrayList<CommandMessage>();
    FTPClient client = null;
    try {/*from   w ww  .  j  av a  2 s.com*/
        client = initConnection();
        for (String fullPathToFile : remoteFtpUriToFile) {
            // should only return one file - since we are using a complete file uri and not a uri to a folder
            FTPFile[] ftpFilesAtPath = client.listFiles(fullPathToFile);
            if (ftpFilesAtPath.length > 0) {
                //String localFileName = fullPathToFile;
                File internalInFile = new File(node.getRouter().getHomePath() + File.separator + "nodes"
                        + File.separator + node.getId() + File.separator + "internal" + File.separator + "in"
                        + File.separator + fullPathToFile.replace("/", "_"));
                FileOutputStream fos = new FileOutputStream(internalInFile);
                logger.info("Downloading file from ftp server:" + fullPathToFile);
                // we have a valid fullPathToFile and there is a file at that fullPathToFile
                boolean status = client.retrieveFile(fullPathToFile, fos);
                if (status) {
                    logger.info("Downloading complete :" + internalInFile);
                    internalInFile.setLastModified(ftpFilesAtPath[0].getTimestamp().getTimeInMillis());

                    // Get part of the message to store for querying purposes
                    String message = getMessage(internalInFile);
                    CommandMessage cmdMessage = new CommandMessage(message, internalInFile);
                    commandMessages.add(cmdMessage);
                } else {
                    logger.error("Failed to download remote file :" + fullPathToFile + " Status code received :"
                            + status);
                }
                fos.close();
            }
        }
    } catch (Exception e) {
        // TODO We need to reset state if we start working again
        node.setNodeStatus(NodeStatus.ERROR);
        node.setStatusMessage(
                "Failed reading files from :" + node.getInBound().getUri() + " Error:" + e.getMessage());
        logStrategy.log(node);
        logger.warn("Connection problem with FTP server.", e);
    } finally {
        if (client != null) {
            try {
                client.logout();
                client.disconnect();
            } catch (IOException e) {
                //ignore
            }
        }
    }
    return commandMessages;
}

From source file:org.jason.mapmaker.server.service.ShapefileMetadataServiceImpl.java

private List<String> getRemoteFilenames(String url, String directory) {

    FTPClient ftp = new FTPClient();
    List<String> filenameList = new ArrayList<String>();

    try {/*from   w  ww .ja v  a  2s .c  o m*/
        int reply;
        ftp.connect(url);
        reply = ftp.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            System.out.println("FTP connection failed for " + url);
        }
        ftp.enterLocalPassiveMode();
        ftp.login("anonymous", "");
        FTPFile[] files = ftp.listFiles(directory);
        for (FTPFile f : files) {
            filenameList.add(f.getName());
        }

        ftp.logout();

    } catch (IOException ex) {

        ex.printStackTrace();
    }

    return filenameList;
}

From source file:org.jboss.ejb3.examples.ch06.filetransfer.FileTransferBean.java

/**
 * Called by the container when the instance is about to be passivated or brought
 * out of service entirely.//from ww  w .  ja  v  a  2  s  . co m
 *
 * @see org.jboss.ejb3.examples.ch06.filetransfer.FileTransferCommonBusiness#disconnect()
 */
@PrePassivate
@PreDestroy
@Override
public void disconnect() {
    // Obtain FTP Client
    final FTPClient client = this.getClient();

    // If exists
    if (client != null) {
        // If connected
        if (client.isConnected()) {
            // Logout
            try {
                client.logout();
                log.info("Logged out of: " + client);
            } catch (final IOException ioe) {
                log.warning("Exception encountered in logging out of the FTP client: " + ioe.getMessage());
            }

            // Disconnect
            try {
                log.fine("Disconnecting: " + client);
                client.disconnect();
                log.info("Disconnected: " + client);
            } catch (final IOException ioe) {
                log.warning("Exception encountered in disconnecting the FTP client: " + ioe.getMessage());
            }

            // Null out the client so it's not serialized
            this.client = null;
        }
    }
}

From source file:org.jnode.protocol.ftp.FTPURLConnection.java

/**
 * @see java.net.URLConnection#getInputStream()
 *///from  w  ww. j a  va 2  s .c om
public InputStream getInputStream() throws IOException {
    FTPClient client = new FTPClient();
    client.connect(host);
    String replyString = client.getReplyString();
    int replyCode = client.getReplyCode();
    if (!FTPReply.isPositiveCompletion(replyCode)) {
        client.disconnect();
        throw new IOException(replyString);
    }
    if (!client.login(username, password)) {
        replyString = client.getReplyString();
        client.logout();
        throw new IOException(replyString);
    }
    client.setFileType(FTP.BINARY_FILE_TYPE);
    client.enterLocalPassiveMode();

    final ByteArrayOutputStream os = new ByteArrayOutputStream();
    try {
        client.retrieveFile(path, os);
        client.logout();
    } finally {
        client.disconnect();
    }
    return new ByteArrayInputStream(os.toByteArray());
}