source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.metadata.repository.cassandra.model;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22
  23 import com.netflix.astyanax.serializers.AbstractSerializer;
  24 import com.netflix.astyanax.serializers.ComparatorType;
  25 import org.apache.cassandra.db.marshal.UTF8Type;
  26 import org.apache.commons.codec.binary.StringUtils;
  27 import org.apache.commons.io.IOUtils;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 import java.io.ByteArrayInputStream;
  32 import java.io.ByteArrayOutputStream;
  33 import java.io.IOException;
  34 import java.nio.ByteBuffer;
  35 import java.nio.charset.Charset;
  36 import java.util.zip.Deflater;
  37 import java.util.zip.DeflaterInputStream;
  38 import java.util.zip.DeflaterOutputStream;
  39 import java.util.zip.InflaterInputStream;
  40
  41
  42 /**
  43  * For Huge String we use a  compression
  44  * @author Olivier Lamy
  45  */
  46 public class HugeStringSerializer
  47     extends AbstractSerializer<String>
  48 {
  49
  50     private Logger logger = LoggerFactory.getLogger( getClass() );
  51
  52     private static final String UTF_8 = "UTF-8";
  53
  54     private static final HugeStringSerializer instance = new HugeStringSerializer();
  55
  56     private static final Charset charset = Charset.forName( UTF_8 );
  57
  58     public static HugeStringSerializer get()
  59     {
  60         return instance;
  61     }
  62
  63     @Override
  64     public ByteBuffer toByteBuffer( String obj )
  65     {
  66         if ( obj == null )
  67         {
  68             return null;
  69         }
  70
  71         try
  72         {
  73             byte[] bytes = compressWithDeflate( StringUtils.getBytesUtf8( obj ) );
  74             return ByteBuffer.wrap( bytes );
  75         }
  76         catch ( IOException e )
  77         {
  78             throw new RuntimeException( "Fail to compress column data", e );
  79         }
  80     }
  81
  82     @Override
  83     public String fromByteBuffer( ByteBuffer byteBuffer )
  84     {
  85         if ( byteBuffer == null )
  86         {
  87             return null;
  88         }
  89
  90         ByteBuffer dup = byteBuffer.duplicate();
  91         try
  92         {
  93             String str = getFromDeflateBytes( dup.array() );
  94             return str;
  95         }
  96         catch ( IOException e )
  97         {
  98             throw new RuntimeException( "Fail to decompress column data", e );
  99         }
 100
 101     }
 102
 103     public String getFromDeflateBytes( byte[] bytes )
 104         throws IOException
 105     {
 106         ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( bytes );
 107         InflaterInputStream inflaterInputStream = new InflaterInputStream( byteArrayInputStream );
 108         return IOUtils.toString( inflaterInputStream );
 109     }
 110
 111     public byte[] compressWithDeflate( byte[] unCompress )
 112         throws IOException
 113     {
 114         try
 115         {
 116             ByteArrayOutputStream buffer = new ByteArrayOutputStream();
 117             DeflaterOutputStream out = new DeflaterOutputStream( buffer, new Deflater( Deflater.BEST_COMPRESSION ) );
 118             out.write( unCompress );
 119             out.finish();
 120             ByteArrayInputStream bais = new ByteArrayInputStream( buffer.toByteArray() );
 121             byte[] res = IOUtils.toByteArray( bais );
 122             return res;
 123         }
 124         catch ( IOException e )
 125         {
 126             logger.debug( "IOException in compressStringWithDeflate", e );
 127             throw e;
 128         }
 129
 130     }
 131
 132     @Override
 133     public ComparatorType getComparatorType()
 134     {
 135         return ComparatorType.BYTESTYPE;
 136     }
 137
 138     @Override
 139     public ByteBuffer fromString( String str )
 140     {
 141         return instance.fromString( str );
 142     }
 143
 144     @Override
 145     public String getString( ByteBuffer byteBuffer )
 146     {
 147         return instance.getString( byteBuffer );
 148     }
 149
 150     /*
 151     private static final String UTF_8 = "UTF-8";
 152     private static final HugeStringSerializer instance = new HugeStringSerializer();
 153     private static final Charset charset = Charset.forName(UTF_8);
 154
 155     public static HugeStringSerializer get() {
 156         return instance;
 157     }
 158
 159     @Override
 160     public ByteBuffer toByteBuffer(String obj) {
 161         if (obj == null) {
 162             return null;
 163         }
 164         return ByteBuffer.wrap(obj.getBytes(charset));
 165     }
 166
 167     @Override
 168     public String fromByteBuffer(ByteBuffer byteBuffer) {
 169         if (byteBuffer == null) {
 170             return null;
 171         }
 172         final ByteBuffer dup = byteBuffer.duplicate();
 173         return charset.decode(dup).toString();
 174     }
 175
 176     @Override
 177     public ComparatorType getComparatorType() {
 178         return ComparatorType.UTF8TYPE;
 179     }
 180
 181     @Override
 182     public ByteBuffer fromString(String str) {
 183         return UTF8Type.instance.fromString(str);
 184     }
 185
 186     @Override
 187     public String getString(ByteBuffer byteBuffer) {
 188         return UTF8Type.instance.getString(byteBuffer);
 189     }
 190     */
 191 }