Successful upload.

src/main/kotlin/com/beust/kobalt/Main.kt

@@ -70,6 +70,7 @@ private class Main @Inject constructor(
             }
 
     public fun run(jc: JCommander, args: Args, argv: Array<String>): Int {
+//        github.uploadRelease()
 
         //
         // Add all the repos from repo contributors (at least those that return values without a Project)
@@ -91,7 +92,6 @@ private class Main @Inject constructor(
         var result = 0
         val latestVersionFuture = github.latestKobaltVersion
         val seconds = benchmark("build", {
-            //            runTest()
             try {
                 result = runWithArgs(jc, args, argv)
             } catch(ex: KobaltException) {

src/main/kotlin/com/beust/kobalt/misc/GithubApi.kt

@@ -8,8 +8,13 @@ import com.google.gson.JsonParser
 import com.google.gson.annotations.SerializedName
 import com.squareup.okhttp.OkHttpClient
 import retrofit.RestAdapter
+import retrofit.RetrofitError
 import retrofit.client.OkClient
+import retrofit.client.Response
 import retrofit.http.*
+import retrofit.mime.MimeUtil
+import retrofit.mime.TypedByteArray
+import retrofit.mime.TypedFile
 import rx.Observable
 import java.io.BufferedReader
 import java.io.File
@@ -28,48 +33,75 @@ import javax.inject.Inject
  */
 public class GithubApi @Inject constructor(val executors: KobaltExecutors) {
     companion object {
-        const val HOST =
+        const val RELEASES_URL = "https://api.github.com/repos/cbeust/kobalt/releases"
-                "https://api.github.com"
-//                "https://developer.github.com/v3/"
-        const val RELEASES_URL = "$HOST/repos/cbeust/kobalt/releases"
     }
 
-    public class ServiceGenerator {
+    fun uploadRelease(): Int {
-        companion object {
+        val releaseName = "TestRelease"
-            val API_BASE_URL = HOST
+        val release = service.getReleaseByTagName(Prop.username, "kobalt", releaseName)
 
-            val httpClient = OkHttpClient()
+        uploadService.uploadRelease(Prop.username, Prop.accessToken, "kobalt", release.id!!, "zipFile", "label",
-            val builder = RestAdapter.Builder()
+                TypedFile("text/plain", File(homeDir("kotlin", "kobalt", "kobalt", "src", "Build.kt"))))
-                    .setEndpoint(API_BASE_URL)
+                .subscribe(
-//                    .baseUrl(API_BASE_URL)
+                        { println("success") },
-//                    .addConverterFactory(GsonConverterFactory.create())
+                        { e: Throwable ->
-
+                            println("error" + (e as RetrofitError).response.bodyContent())
-            class Contributor {
+                            println("")
-                var login: String? = null
+                        },
-                var contributions: Int? = null
+                        { println("complete") }
+                )
+        println("createRelease()")
+        //                service.createRelease(username, accessToken, "kobalt",
+        ////                        hashMapOf("tag_name" to "0.502tagName")
+        //                        CreateRelease(releaseName)
+        ////                        CreateRelease().apply { tag_name = "0.500tagName"}
+        ////                        CreateRelease("0.500tagName",
+        ////                        "master", "0.500name",
+        ////                        "A test release",
+        ////                        draft = false, prerelease = true)
+        //                )
+        //                    .map { response: CreateReleaseResponse? ->
+        //                        uploadRelease(response?.id!!)
+        //                        println("Received id " + response?.id)
+        //                    }
+        //                .subscribe(
+        //                        { println("success") },
+        //                        { e: Throwable ->
+        //                            println("error" + (e as RetrofitError).response.bodyContent())
+        //                        },
+        //                        { println("complete")}
+        //                )
+        ////                    })
+        Thread.sleep(10000)
+        return 0
     }
 
+    //
+    // Read only Api
+    //
+
+    private val service = RestAdapter.Builder()
+            .setLogLevel(RestAdapter.LogLevel.FULL)
+            .setClient(OkClient(OkHttpClient()))
+            .setEndpoint("https://api.github.com")
+            .build()
+            .create(Api::class.java)
+
     class Release {
         var name: String? = null
         var prerelease: Boolean? = null
     }
 
-            class UploadReleaseResponse(var id: String? = null)
-
     class CreateRelease(@SerializedName("tag_name") var tag_name: String? = null)
-//            class CreateRelease(
-//                    @Query("tag_name") tag_name: String,
-//                    @Query("target_commitish") target: String,
-//                    @Query("name") name: String,
-//                    @Query("body") body: String,
-//                    @Query("draft") draft : Boolean,
-//                    @Query("prerelease") prerelease: Boolean
-//            )
     class CreateReleaseResponse(var id: String? = null)
+    class GetReleaseResponse(var id: String? = null,
+            @SerializedName("upload_url") var uploadUrl: String? = null)
 
     interface Api {
-                @GET("/repos/{owner}/{repo}/contributors")
+
-                fun contributors(@Path("owner") owner: String, @Path("repo") repo: String): List<Contributor>
+        @GET("/repos/{owner}/{repo}/releases/tags/{tag}")
+        fun getReleaseByTagName(@Path("owner") owner: String, @Path("repo") repo: String,
+                @Path("tag") tagName: String): GetReleaseResponse
 
         @GET("/repos/{owner}/{repo}/releases")
         fun releases(@Path("owner") owner: String, @Path("repo") repo: String): List<Release>
@@ -80,7 +112,22 @@ public class GithubApi @Inject constructor(val executors: KobaltExecutors) {
                 @Path("repo") repo: String,
                 @Body createRelease: CreateRelease
         ): Observable<CreateReleaseResponse>
+    }
 
+    //
+    // Upload Api
+    //
+
+    val uploadService = RestAdapter.Builder()
+            .setEndpoint("https://uploads.github.com/")
+            .setLogLevel(RestAdapter.LogLevel.FULL)
+            .setClient(OkClient(OkHttpClient()))
+            .build()
+            .create(UploadApi::class.java)
+
+    class UploadReleaseResponse(var id: String? = null)
+
+    interface UploadApi {
         @POST("/repos/{owner}/{repo}/releases/{id}/assets")
         fun uploadRelease(@Path("owner") owner: String,
                 @Query("access_token") accessToken: String,
@@ -88,25 +135,50 @@ public class GithubApi @Inject constructor(val executors: KobaltExecutors) {
                 @Path("id") id: String,
                 @Query("name") name: String,
                 @Query("label") label: String,
-                        @Body file: File,
+                @Body file: TypedFile)
-                        @Query("Content-Type") contentType: String = "application/zip")
+                //                        @Query("Content-Type") contentType: String = "text/plain")//"application/zip")
                 : Observable<UploadReleaseResponse>
-
     }
 
-            val service : Api by lazy { ServiceGenerator.createService(Api::class.java) }
+    val latestKobaltVersion: Future<String>
-
+        get() {
-            fun <S> createService(serviceClass: Class<S>): S {
+            val callable = Callable<String> {
-                val retrofit = builder
+                var result = "0"
-                        .setEndpoint(HOST)
+                try {
-                        .setLogLevel(RestAdapter.LogLevel.FULL)
+                    val ins = URL(RELEASES_URL).openConnection().inputStream
-                        .setClient(OkClient(OkHttpClient()))
+                    @Suppress("UNCHECKED_CAST")
-
+                    val reader = BufferedReader(InputStreamReader(ins))
-                //                        .setClient(httpClient)
+                    val jo = JsonParser().parse(reader) as JsonArray
-                        .build()
+                    //                    val jo = Parser().parse(ins) as JsonArray<JsonObject>
-                return retrofit.create(serviceClass)
+                    if (jo.size() > 0) {
+                        var versionName = (jo.get(0) as JsonObject).get("name").asString
+                        if (versionName == null) {
+                            versionName = (jo.get(0) as JsonObject).get("tag_name").asString
+                        }
+                        if (versionName != null) {
+                            result = versionName
+                        }
+                    }
+                } catch(ex: IOException) {
+                    warn("Couldn't load the release URL: $RELEASES_URL")
+                }
+                result
+            }
+            return executors.miscExecutor.submit(callable)
+        }
 }
 
+fun Response.bodyContent() : String {
+    val bodyBytes = (body as TypedByteArray).bytes
+    val bodyMime = body.mimeType()
+    val bodyCharset = MimeUtil.parseCharset(bodyMime, "utf-8")
+    val result = String(bodyBytes, bodyCharset)
+    return result
+    //            return new Gson().fromJson(data, type);
+}
+
+class Prop {
+    companion object {
         const val ACCESS_TOKEN_PROPERTY = "github.accessToken"
         const val USERNAME_PROPERTY = "github.username"
 
@@ -136,64 +208,5 @@ public class GithubApi @Inject constructor(val executors: KobaltExecutors) {
 
         val accessToken: String get() = fromProperties(ACCESS_TOKEN_PROPERTY)
         val username: String get() = fromProperties(USERNAME_PROPERTY)
-
-            fun uploadRelease() : Int {
-                println("createRelease()")
-                service.createRelease(username, accessToken, "kobalt",
-//                        hashMapOf("tag_name" to "0.502tagName")
-                        CreateRelease("0.503tagName")
-//                        CreateRelease().apply { tag_name = "0.500tagName"}
-//                        CreateRelease("0.500tagName",
-//                        "master", "0.500name",
-//                        "A test release",
-//                        draft = false, prerelease = true)
-                )
-                    .map { response: CreateReleaseResponse? ->
-                        uploadRelease(response?.id!!)
-                        println("Received id " + response?.id)
-                    }
-                .subscribe(
-                        { println("success") },
-                        { e: Throwable -> println("error" + e)},
-                        { println("complete")}
-                )
-//                    })
-                Thread.sleep(10000)
-                return 0
-            }
-
-            fun uploadRelease(id: String) {
-                service.uploadRelease(username, accessToken, "kobalt", id, "The zip file", "The label",
-                        File(homeDir("kotlin", "kobalt", "src", "Build.kt")))
-            }
-        }
-    }
-
-
-    val latestKobaltVersion: Future<String>
-        get() {
-            val callable = Callable<String> {
-                var result = "0"
-                try {
-                    val ins = URL(RELEASES_URL).openConnection().inputStream
-                    @Suppress("UNCHECKED_CAST")
-                    val reader = BufferedReader(InputStreamReader(ins))
-                    val jo = JsonParser().parse(reader) as JsonArray
-//                    val jo = Parser().parse(ins) as JsonArray<JsonObject>
-                    if (jo.size() > 0) {
-                        var versionName = (jo.get(0) as JsonObject).get("name").asString
-                        if (versionName == null) {
-                            versionName = (jo.get(0) as JsonObject).get("tag_name").asString
-                        }
-                        if (versionName != null) {
-                            result = versionName
-                        }
-                    }
-                } catch(ex: IOException) {
-                    warn("Couldn't load the release URL: $RELEASES_URL")
-                }
-                result
-            }
-            return executors.miscExecutor.submit(callable)
     }
 }