notion.api.v1.http.HttpUrlConnPatchMethodWorkaround.kt Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */
package notion.api.v1.http

import java.lang.reflect.Field
import java.net.HttpURLConnection
import java.net.ProtocolException
import java.security.AccessController
import java.security.PrivilegedActionException
import java.security.PrivilegedExceptionAction

/**
 * Thanks to
 * https://github.com/eclipse-ee4j/jersey/blob/3.0.2/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java#L473
 */
object HttpUrlConnPatchMethodWorkaround {

    fun setPatchRequestMethod(conn: HttpURLConnection) {
        try {
            conn.requestMethod = "PATCH" // Check whether we are running on a buggy JRE
        } catch (pe: ProtocolException) {
            try {
                AccessController.doPrivileged(
                    PrivilegedExceptionAction {
                        try {
                            conn.requestMethod = "PATCH"
                        } catch (pe: ProtocolException) {
                            var connectionClass: Class<*>? = conn.javaClass
                            val delegateField: Field?
                            try {
                                delegateField = connectionClass!!.getDeclaredField("delegate")
                                delegateField.isAccessible = true
                                val delegateConnection = delegateField[conn] as HttpURLConnection
                                setPatchRequestMethod(delegateConnection)
                            } catch (e: NoSuchFieldException) {
                                // Ignore for now, keep going
                            } catch (e: IllegalArgumentException) {
                                throw RuntimeException(e)
                            } catch (e: IllegalAccessException) {
                                throw RuntimeException(e)
                            }
                            try {
                                var methodField: Field
                                while (connectionClass != null) {
                                    try {
                                        methodField = connectionClass.getDeclaredField("method")
                                    } catch (e: NoSuchFieldException) {
                                        connectionClass = connectionClass.superclass
                                        continue
                                    }
                                    methodField.isAccessible = true
                                    methodField[conn] = "PATCH"
                                    break
                                }
                            } catch (e: Exception) {
                                throw RuntimeException(e)
                            }
                        }
                        null
                    })
            } catch (e: PrivilegedActionException) {
                val cause: Throwable? = e.cause
                if (cause is RuntimeException) {
                    throw cause
                } else {
                    throw RuntimeException(cause)
                }
            }
        }
    }
}