private Class generateProxy() {
try {
JavaClassLoader jLoader = new JavaClassLoader(_cl.getClassLoader());
JavaClass jClass = new JavaClass(jLoader);
jClass.setAccessFlags(Modifier.PUBLIC);
ConstantPool cp = jClass.getConstantPool();
jClass.setWrite(true);
jClass.setMajor(49);
jClass.setMinor(0);
String superClassName = _cl.getName().replace('.', '/');
String thisClassName = superClassName + "$BeanProxy";
jClass.setSuperClass(superClassName);
jClass.setThisClass(thisClassName);
jClass.addInterface("java/io/Serializable");
jClass.addInterface("com/caucho/config/inject/HandleAware");
generateConstructors(jClass, superClassName);
generateWriteReplace(jClass);
generateSetHandle(jClass);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
WriteStream out = Vfs.openWrite(bos);
jClass.write(out);
out.close();
byte[] buffer = bos.toByteArray();
if (false) {
String userName = System.getProperty("user.name");
out = Vfs.lookup("file:/tmp/" + userName + "/qa/temp.class").openWrite();
out.write(buffer, 0, buffer.length);
out.close();
}
String cleanName = thisClassName.replace('/', '.');
_proxyClass = (Class<X>) new ProxyClassLoader().loadClass(cleanName, buffer);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
return _proxyClass;
}
private Path writeTempFile(Node node) throws IOException {
Path workDir = CauchoSystem.getWorkPath().lookup("_xsl");
workDir.mkdirs();
// Path temp = workDir.createTempFile("tmp", "xsl");
WriteStream os = Vfs.lookup("null:").openWrite();
Crc64Stream crcStream = new Crc64Stream(os.getSource());
os.init(crcStream);
try {
XmlPrinter printer = new XmlPrinter(os);
printer.printNode(node);
} finally {
os.close();
}
long crc = crcStream.getCRC();
CharBuffer cb = new CharBuffer();
Base64.encode(cb, crc);
String crcValue = cb.toString().replace('/', '-');
Path xslPath = workDir.lookup(crcValue + ".xsl");
// temp.renameTo(xslPath);
return xslPath;
}
/** Tries to close the log. */
private void closeLogStream() {
try {
WriteStream os = _os;
_os = null;
if (os != null) os.close();
} catch (Throwable e) {
// can't log in log routines
}
try {
WriteStream zipOut = _zipOut;
_zipOut = null;
if (zipOut != null) zipOut.close();
} catch (Throwable e) {
// can't log in log routines
}
}
public RepositoryTagMap(
AbstractRepository repository,
RepositoryTagMap parent,
Map<String, RepositoryTagEntry> tagMap)
throws IOException {
_tagMap = Collections.unmodifiableMap(tagMap);
long now = Alarm.getCurrentTime();
if (parent.getSequence() < now) _sequence = now;
else _sequence = parent.getSequence() + 1;
TempStream os = new TempStream();
WriteStream out = new WriteStream(os);
writeTagMap(out);
out.close();
String tagHash;
InputStream is = os.getInputStream();
try {
tagHash = repository.addBlob(is);
} finally {
is.close();
}
_tree = new GitTree();
_tree.addBlob("tags", 0775, tagHash);
for (String key : tagMap.keySet()) {
RepositoryTagEntry entry = tagMap.get(key);
String sha1 = entry.getTagEntryHash();
String root = entry.getRoot();
_tree.addBlob(sha1, 0644, sha1);
GitType type = repository.getType(root);
if (type == GitType.BLOB) _tree.addBlob(root, 0644, root);
else if (type == GitType.TREE) _tree.addDir(root, root);
else throw new IllegalStateException(L.l("'{0}' has an unknown type {1}", root, type));
}
String treeHash = repository.addTree(_tree);
_commit = new GitCommit();
_commit.setTree(treeHash);
_commit.put("sequence", String.valueOf(_sequence));
_commitHash = repository.addCommit(_commit);
}
protected void writeResponse(OutputStream out, Object result) throws IOException, RestException {
WriteStream ws = Vfs.openWrite(out);
try {
XMLStreamWriterImpl writer = new XMLStreamWriterImpl(ws);
_marshaller.marshal(result, writer);
} catch (JAXBException e) {
throw new RuntimeException(e);
} finally {
ws.close();
}
}
public static void writeDepend(Path dependPath, ArrayList<PersistentDependency> dependList)
throws IOException {
WriteStream os = dependPath.openWrite();
try {
for (int i = 0; i < dependList.size(); i++) {
PersistentDependency dependency = dependList.get(i);
if (dependency instanceof Depend) {
Depend depend = (Depend) dependency;
os.print('"');
os.print(depend.getPath().getNativePath());
os.print("\" \"");
os.print(depend.getDigest());
os.println("\"");
}
}
} finally {
os.close();
}
}
private static void readMultipartStream(
Env env,
MultipartStream ms,
ArrayValue postArray,
ArrayValue files,
boolean addSlashesToValues,
boolean isAllowUploads)
throws IOException {
ReadStream is;
while ((is = ms.openRead()) != null) {
String attr = (String) ms.getAttribute("content-disposition");
if (attr == null || !attr.startsWith("form-data")) {
// XXX: is this an error?
continue;
}
String name = getAttribute(attr, "name", addSlashesToValues);
String filename = getAttribute(attr, "filename", addSlashesToValues);
if (filename != null) {
int slashIndex = filename.lastIndexOf('/');
int slashIndex2 = filename.lastIndexOf('\\');
slashIndex = Math.max(slashIndex, slashIndex2);
if (slashIndex >= 0) filename = filename.substring(slashIndex + 1);
}
int bracketIndex = -1;
if (name != null) bracketIndex = name.lastIndexOf(']');
if (bracketIndex >= 0 && bracketIndex < name.length() - 1) {
// php/085c
} else if (filename == null) {
StringValue value = env.createStringBuilder();
value.appendReadAll(is, Integer.MAX_VALUE);
if (name != null) {
addFormValue(env, postArray, name, value, null, addSlashesToValues);
} else {
env.warning(L.l("file upload is missing name and filename"));
}
} else {
if (!isAllowUploads) {
continue;
}
String tmpName = "";
long tmpLength = 0;
// A POST file upload with an empty string as the filename does not
// create a temp file in the upload directory.
if (filename.length() > 0) {
Path tmpPath = env.getUploadDirectory().createTempFile("php", ".tmp");
env.addRemovePath(tmpPath);
WriteStream os = tmpPath.openWrite();
try {
os.writeStream(is);
} finally {
os.close();
}
tmpName = tmpPath.getFullPath();
tmpLength = tmpPath.getLength();
}
// php/0865
//
// A header like "Content-Type: image/gif" indicates the mime type
// for an uploaded file.
String mimeType = getAttribute(attr, "mime-type", addSlashesToValues);
if (mimeType == null) {
mimeType = (String) ms.getAttribute("content-type");
// php/085f
if (mimeType != null && mimeType.endsWith(";"))
mimeType = mimeType.substring(0, mimeType.length() - 1);
}
// php/0864
//
// mime type is empty string when no file is uploaded.
if (filename.length() == 0) {
mimeType = "";
}
long maxFileSize = Long.MAX_VALUE;
Value maxFileSizeV = postArray.get(MAX_FILE_SIZE);
if (!maxFileSizeV.isNull()) maxFileSize = maxFileSizeV.toLong();
if (name != null) {
addFormFile(
env,
files,
name,
filename,
tmpName,
mimeType,
tmpLength,
addSlashesToValues,
maxFileSize);
} else {
addFormFile(
env, files, filename, tmpName, mimeType, tmpLength, addSlashesToValues, maxFileSize);
}
}
}
}
private void movePathToArchive(Path savedPath) {
if (savedPath == null) return;
synchronized (_logLock) {
closeLogStream();
}
Path path = getPath();
String savedName = savedPath.getTail();
try {
if (!savedPath.getParent().isDirectory()) savedPath.getParent().mkdirs();
} catch (Exception e) {
logWarning(L.l("Can't open archive directory {0}", savedPath.getParent()), e);
}
try {
if (path.exists()) {
WriteStream os = null;
OutputStream out = null;
// *.gz and *.zip are copied. Others are just renamed
if (savedName.endsWith(".gz")) {
os = savedPath.openWrite();
out = new GZIPOutputStream(os);
} else if (savedName.endsWith(".zip")) {
os = savedPath.openWrite();
ZipOutputStream zip = new ZipOutputStream(os);
String entryName = savedName.substring(0, savedName.length() - 4);
ZipEntry entry = new ZipEntry(entryName);
zip.putNextEntry(entry);
out = zip;
}
if (out != null) {
try {
path.writeToStream(out);
} finally {
try {
out.close();
} catch (Exception e) {
// can't log in log rotation routines
}
try {
if (out != os) os.close();
} catch (Exception e) {
// can't log in log rotation routines
}
}
} else {
path.renameTo(savedPath);
}
}
} catch (Exception e) {
logWarning(L.l("Error rotating logs: {0}", e.toString()), e);
}
try {
path.remove();
/*
try {
if (! path.truncate())
path.remove();
} catch (IOException e) {
path.remove();
throw e;
}
*/
} catch (Exception e) {
logWarning(L.l("Error truncating logs"), e);
}
if (_rolloverCount > 0) removeOldLogs();
}
