Java Windowsファイル共有サービス(CIFS)経由でファイルを書き込む

Java Windowsファイル共有サービス(CIFS)経由でファイルを書き込む

Java | JAX-RS |

• アプリケーションサーバー等、サービスで動くアプリケーションは、ログインユーザーとは別権限で動作しており、ファイル共有されたドライブのファイル参照、書き出しが出来ない。
• JCIFSライブラリを利用して対応する
  • http://jcifs.samba.org/

書き込みユーティリティ例

package info.typea.util;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.MalformedURLException;

import jcifs.smb.SmbException;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbFileOutputStream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * ファイルシステムユーティリティ
 *
 */
public class FileSystemUtils {
    protected static Logger logger = LoggerFactory.getLogger(FileSystemUtils.class);
    private static final int BUF_SIZE = 4096;
    
    private FileSystemUtils(){}
    
    /**
     * 通常のファイルシステムもしくは CIFS(Windowsファイル共有サービス) にファイルを書き込む
     * 
     * @param is 書き込み内容
     * @param file 書き込み対象ファイル
     * @param isCifs CIFS か否か
     * @return
     */
    public static FileSystemUtilInfo writeToFile(
            InputStream is, 
            File file,
            boolean isCifs,            
            String user, 
            String password) {
        
        if (isCifs) {
            return writeToCifsFile(is, file, user, password);
        } else {
            return writeToLocalFile(is, file);
        }
    }
         
    /**
     * java.io.File から、SmbFile オブジェクトを生成する
     * 
     * @param targetFile
     * @param user
     * @param password
     * @return
     */
    public static SmbFile createSmbFileFromFile(
            File targetFile,            
            String user, 
            String password) {
        
        SmbFile file = null;
        try {
            file = new SmbFile(
                cifsUrl( 
                    user,
                    cisfPassword(password),
                    cisfPath(targetFile.getAbsolutePath())));
            
        } catch (MalformedURLException e) {
            // TODO
        }
        
        return file;
    }
     
    /**
     * 通常のファイルシステムにファイルを作成
     * 
     * @param is
     * @param targetFile
     * @return
     */
    private static FileSystemUtilInfo writeToLocalFile(InputStream is, File targetFile) {
        
        FileSystemUtilInfo info = new FileSystemUtilInfo();
        
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(targetFile);
            BufferedInputStream bis = new BufferedInputStream(is);
            
            int len = 0;
            long fileSize = 0;
            byte[] buffer = new byte[BUF_SIZE];
            while ((len = bis.read(buffer)) >= 0) { 
                fos.write(buffer,0, len);
                fileSize += len;
            }
            info.setFileSize(fileSize);
            
            bis.close();
        } catch(Exception e) {
            throw new IllegalStateException(e);
        } finally {
            try {
                fos.close();
            } catch (Exception e2) {}
        }
        return info;
    }
    
    /**
     * CIFS ファイルシステムにファイルを作成
     * 
     * @param is
     * @param targetFile
     * @return
     * @see http://jcifs.samba.org/src/docs/api/jcifs/smb/SmbFile.html
     */
    private static FileSystemUtilInfo writeToCifsFile(
            InputStream is, 
            File targetFile, 
            String user, 
            String password) {
                
        FileSystemUtilInfo info = new FileSystemUtilInfo();
        try {
            makeCifsDirectories(targetFile.getParentFile(), user, password);
            SmbFile file = new SmbFile(
                cifsUrl( 
                    user,
                    cisfPassword(password),
                    cisfPath(targetFile.getAbsolutePath())));

            if (!file.exists()) {
                file.createNewFile();
            }
            SmbFileOutputStream fos = new SmbFileOutputStream(file);
            BufferedInputStream bis = new BufferedInputStream(is);
            
            int len = 0;
            long fileSize = 0;
            byte[] buffer = new byte[BUF_SIZE];
            while ((len = bis.read(buffer)) >= 0) { 
                fos.write(buffer,0, len);
                fileSize += len;
            }
            info.setFileSize(fileSize);
            
            bis.close();
            
        } catch (Exception e) {
            // TODO
        }
        
        return info;
    }
    
    /**
     * CIFS ディレクトリが存在しない場合、作成する
     * 
     * @param dir
     * @param user
     * @param password
     * @throws MalformedURLException
     * @throws SmbException
     */
    private static void makeCifsDirectories(
            File dir, 
            String user, 
            String password) throws MalformedURLException, SmbException {
        
        SmbFile cifsDir = new SmbFile(
            cifsUrl( 
                user,
                cisfPassword(password),
                cisfPath(dir.getAbsolutePath())));
        
        if (!cifsDir.exists()) {
            cifsDir.mkdirs();
        }
    }
    
    /**
     * CIFS アクセス URL
     * @param user
     * @param password
     * @param path
     * @return
     */
    private static String cifsUrl(String user, String password, String path) {
        return String.format("smb://%s:%s@%s",user,password,path);
    }
    /**
     * '@' is URL encoded with the '%40' hexcode escape
     * 
     * @param password
     * @return
     */
    private static String cisfPassword(String password) {
        return password.replaceAll("@", "%40");
    }
    
    /**
     * "\\" で始まる、UNCパス を "server/share/path/to/file.txt" のような書式に変換
     * 
     * @param path
     * @return
     */
    private static String cisfPath(String path) {
        // \\ を取り除く
        if (path.substring(0,2).equals("\\\\")) {
            path = path.substring(2);
        }
        return path.replaceAll("\\\\", "\\/");
    }

    
    /**
     *  結果情報
     *
     */
    public static class FileSystemUtilInfo {
        private long fileSize;

        public long getFileSize() {
            return fileSize;
        }

        public void setFileSize(long fileSize) {
            this.fileSize = fileSize;
        }
    }
}

JAX-RS のプロバイダ例

• SmbFile を JAX-RS のレスポンスとして返すためのプロバイダ

package info.typea.provider;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;

import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Provider;

import jcifs.smb.SmbException;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbFileInputStream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Windows ファイル共有 サービス(CIFS) ファイル 用 JAX-RS プロバイダー
 * 
 * @see org.apache.wink.common.internal.providers.entity.FileProvider
 */
@Provider
@Produces({ "*/*" })
@Consumes({ "*/*" })
public class SmbFileProvider implements MessageBodyWriter<SmbFile> {
    private static final Logger logger = LoggerFactory.getLogger(SmbFileProvider.class);

    @Override
    public long getSize(SmbFile t, Class<?> type, Type genericType, Annotation[] annotations,
            MediaType mediaType) {
        try {
            return t.length();
        } catch (SmbException e) {
            return 0;
        }
    }

    @Override
    public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations,
            MediaType mediaType) {
        return SmbFile.class.isAssignableFrom(type);
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public void writeTo(
            SmbFile t, 
            Class<?> type, 
            Type genericType, 
            Annotation[] annotations,
            MediaType mediaType, 
            MultivaluedMap<String, Object> httpHeaders,
            OutputStream entityStream) throws IOException, WebApplicationException {

        try {
            final SmbFile smbFile = t;
            final OutputStream os = entityStream;
            
            AccessController.doPrivileged(new PrivilegedExceptionAction() {
                public Object run() throws IOException {
                    if ((!(smbFile.canRead())) || (smbFile.isDirectory())) {
                        if (SmbFileProvider.logger.isWarnEnabled()) {
                            SmbFileProvider.logger.error(String
                                .format("cannotUseFileAsResponse %s", smbFile.getPath()));
                        }

                        throw new WebApplicationException();
                    }
                    SmbFileInputStream fis = new SmbFileInputStream(smbFile);
                    try {
                        SmbFileProvider.this.pipe(fis, os);
                    } finally {
                        fis.close();
                    }

                    return null;
                }
            });
        } catch (PrivilegedActionException e) {
            if (e.getException() instanceof IOException)
                throw ((IOException) e.getException());
            if (e.getException() instanceof WebApplicationException)
                throw ((WebApplicationException) e.getException());
            throw new WebApplicationException(e.getException());
        }
    }

    private void pipe(InputStream is, OutputStream os) throws IOException {
        byte[] ba = new byte[1024];
        int i = is.read(ba);
        while (i != -1) {
            os.write(ba, 0, i);
            i = is.read(ba);
        }
    }
}