package com.kodcu.rapid.path;
import com.kodcu.rapid.config.DockerClient;
import com.kodcu.rapid.pojo.ResponseFrame;
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonObject;
import javax.ws.rs.DELETE;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Response;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Objects;
import static com.kodcu.rapid.util.Constants.CONTAINERS;
import static com.kodcu.rapid.util.Constants.MESSAGE;
import static com.kodcu.rapid.util.Networking.deleteResponse;
import static com.kodcu.rapid.util.Networking.getResponse;
import static com.kodcu.rapid.util.Networking.postResponse;
import static javax.ws.rs.core.Response.Status.NOT_FOUND;
import static javax.ws.rs.core.Response.Status.OK;
/**
* Created by Hakan on 2/10/2016.
*/
@Path("containers")
public class Container extends DockerClient {
@GET
@Path("json")
public Response listContainers(@DefaultValue("false") @QueryParam("all") String all,
@QueryParam("limit") int limit,
@DefaultValue("false") @QueryParam("size") String size,
@QueryParam("filters") String filters) throws UnsupportedEncodingException {
WebTarget target = resource().path(CONTAINERS).path("json").queryParam("all", all).queryParam("size", size);
if (limit != 0)
target = target.queryParam("limit", limit);
if (Objects.nonNull(filters))
target = target.queryParam("filters", URLEncoder.encode(filters, "UTF-8"));
Response response = getResponse(target);
try {
if (response.getStatus() == OK.getStatusCode())
return Response.ok(response.readEntity(JsonArray.class)).build();
else
return Response.status(response.getStatus()).entity(response.readEntity(JsonObject.class)).build();
} finally {
response.close();
}
}
@GET
@Path("{id}/json")
public Response inspectContainer(@PathParam("id") String containerId,
@DefaultValue("false") @QueryParam("size") String size) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId).path("json")
.queryParam("size", size);
Response response = getResponse(target);
try {
return Response.status(response.getStatus()).entity(response.readEntity(JsonObject.class)).build();
} finally {
response.close();
}
}
@GET
@Path("{id}/top")
public Response containerTopProcess(@PathParam("id") String containerId,
@DefaultValue("-ef") @QueryParam("ps_args") String ps) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId).path("top")
.queryParam("ps", ps);
Response response = getResponse(target);
try {
return Response.status(response.getStatus())
.entity(response.readEntity(JsonObject.class))
.build();
} finally {
response.close();
}
}
@GET
@Path("{id}/logs")
public ResponseFrame getContainerLogs(@PathParam("id") String containerId,
@DefaultValue("false") @QueryParam("stdout") String stdout,
@DefaultValue("false") @QueryParam("stderr") String stderr,
@DefaultValue("0") @QueryParam("since") String since,
@DefaultValue("false") @QueryParam("timestamps") String timestamps,
@DefaultValue("all") @QueryParam("tail") String tail) {
WebTarget target = resource().path(CONTAINERS).path(containerId).path("logs");
// follow = false always
target = target.queryParam("follow", false)
.queryParam("stdout", stdout)
.queryParam("stderr", stderr)
.queryParam("since", since)
.queryParam("timestamps", timestamps)
.queryParam("tail", tail);
Response response = getResponse(target);
ResponseFrame frame = new ResponseFrame();
try {
if (response.getStatus() == OK.getStatusCode()) {
String entity = response.readEntity(String.class);
frame.setMessage(entity);
} else if (response.getStatus() == NOT_FOUND.getStatusCode()) {
frame.setMessage("No such container: " + containerId);
} else {
frame.setMessage("Something went wrong.");
}
} finally {
response.close();
}
return frame;
}
@GET
@Path("{id}/changes")
public Response getContainerChanges(@PathParam("id") String containerId) {
WebTarget target = resource().path(CONTAINERS).path(containerId).path("changes");
Response response = getResponse(target);
try {
if (response.getStatus() == OK.getStatusCode())
return Response.ok(response.readEntity(JsonArray.class)).build();
else
return Response.status(response.getStatus())
.entity(response.readEntity(JsonObject.class))
.build();
} finally {
response.close();
}
}
@POST
@Path("{id}/start")
public Response startContainer(@PathParam("id") String id,
@QueryParam("detachKeys") String detachKeys) {
WebTarget target = resource().path(CONTAINERS)
.path(id)
.path("start");
Response response = postResponse(target);
String entity = response.readEntity(String.class);
try {
if (entity.isEmpty()) {
return Response.ok(Json.createObjectBuilder().add(MESSAGE, id + " started.").build())
.build();
} else {
return Response.status(response.getStatus())
.entity(Json.createReader(new StringReader(entity)).read())
.build();
}
} finally {
response.close();
}
}
@POST
@Path("{id}/stop")
public Response stopContainer(@PathParam("id") String containerId,
@QueryParam("t") String t) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId)
.path("stop");
if (Objects.nonNull(t))
target = target.queryParam("t", t);
Response response = postResponse(target);
String entity = response.readEntity(String.class);
try {
if (entity.isEmpty()) {
return Response.ok(Json.createObjectBuilder().add(MESSAGE, containerId + " stopped.").build())
.build();
} else {
return Response.status(response.getStatus())
.entity(Json.createReader(new StringReader(entity)).read())
.build();
}
} finally {
response.close();
}
}
@POST
@Path("{id}/restart")
public Response restartContainer(@PathParam("id") String containerId,
@QueryParam("t") String t) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId)
.path("restart");
if (Objects.nonNull(t))
target = target.queryParam("t", t);
Response response = postResponse(target);
String entity = response.readEntity(String.class);
try {
if (entity.isEmpty()) {
return Response.ok(Json.createObjectBuilder().add(MESSAGE, containerId + " restarted.").build())
.build();
} else {
return Response.status(response.getStatus())
.entity(Json.createReader(new StringReader(entity)).read())
.build();
}
} finally {
response.close();
}
}
@POST
@Path("{id}/kill")
public Response killContainer(@PathParam("id") String containerId,
@DefaultValue("SIGKILL") @QueryParam("signal") String signal) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId)
.path("kill")
.queryParam("signal", signal);
Response response = postResponse(target);
String entity = response.readEntity(String.class);
try {
if (entity.isEmpty()) {
return Response.ok(Json.createObjectBuilder().add(MESSAGE, containerId + " killed.").build())
.build();
} else {
return Response
.status(response.getStatus())
.entity(Json.createReader(new StringReader(entity)).read())
.build();
}
} finally {
response.close();
}
}
@POST
@Path("{id}/update")
public Response updateContainer(@PathParam("id") String containerId,
JsonObject content) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId)
.path("update");
Response response = postResponse(target, content);
try {
JsonObject entity = response.readEntity(JsonObject.class);
return Response.status(response.getStatus())
.entity(entity).build();
} finally {
response.close();
}
}
@POST
@Path("{id}/rename")
public Response renameContainer(@PathParam("id") String containerId,
@QueryParam("name") String name) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId)
.path("rename")
.queryParam("name", name);
Response response = postResponse(target);
String entity = response.readEntity(String.class);
try {
if (entity.isEmpty()) {
return Response.ok(Json.createObjectBuilder().add(MESSAGE, containerId + " renamed as " + name).build())
.build();
} else {
return Response.status(response.getStatus()).entity(Json.createReader(new StringReader(entity)).read()).build();
}
} finally {
response.close();
}
}
@POST
@Path("{id}/pause")
public Response pauseContainer(@PathParam("id") String containerId) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId)
.path("pause");
Response response = postResponse(target);
String entity = response.readEntity(String.class);
try {
if (entity.isEmpty()) {
return Response.ok(Json.createObjectBuilder().add(MESSAGE, containerId + " paused.").build())
.build();
} else {
return Response.status(response.getStatus())
.entity(Json.createReader(new StringReader(entity)).read())
.build();
}
} finally {
response.close();
}
}
@POST
@Path("{id}/unpause")
public Response unpauseeContainer(@PathParam("id") String containerId) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId)
.path("unpause");
Response response = postResponse(target);
String entity = response.readEntity(String.class);
try {
if (entity.isEmpty()) {
return Response.ok(Json.createObjectBuilder().add(MESSAGE, containerId + " unpaused.").build())
.build();
} else {
return Response.status(response.getStatus())
.entity(Json.createReader(new StringReader(entity)).read())
.build();
}
} finally {
response.close();
}
}
@DELETE
@Path("{id}")
public Response deleteContainer(@PathParam("id") String containerId,
@DefaultValue("false") @QueryParam("v") String v,
@DefaultValue("false") @QueryParam("force") String force) {
WebTarget target = resource().path(CONTAINERS)
.path(containerId)
.queryParam("v", v)
.queryParam("force", force);
Response response = deleteResponse(target);
String entity = response.readEntity(String.class);
try {
if (entity.isEmpty()) {
return Response.ok(Json.createObjectBuilder().add(MESSAGE, containerId + " deleted.").build())
.build();
} else {
return Response.status(response.getStatus())
.entity(Json.createReader(new StringReader(entity)).read())
.build();
}
} finally {
response.close();
}
}
@POST
@Path("prune")
public Response prune(@QueryParam("filter") String filter) {
WebTarget target = resource().path(CONTAINERS)
.path("prune");
if (Objects.nonNull(filter))
target = target.queryParam("filter", filter);
Response response = postResponse(target);
try {
JsonObject entity = response.readEntity(JsonObject.class);
return Response.status(response.getStatus())
.entity(entity)
.build();
} finally {
response.close();
}
}
@POST
@Path("create")
public Response createContainer(@QueryParam("name") String name, JsonObject content) {
WebTarget target = resource().path(CONTAINERS).path("create");
if (Objects.nonNull(name))
target = target.queryParam("name", name);
Response response = postResponse(target, content);
try {
return Response.status(response.getStatus())
.entity(response.readEntity(JsonObject.class))
.build();
} finally {
response.close();
}
}
}
