// Write marshals the value to byte slice and set the Content-Type Header.
func (e entityMsgPackAccess) Write(resp *restful.Response, status int, v interface{}) error {
if v == nil {
resp.WriteHeader(status)
// do not write a nil representation
return nil
}
resp.WriteHeader(status)
return msgpack.NewEncoder(resp).Encode(v)
}
// getContainerLogs handles containerLogs request against the Kubelet
func (s *Server) getContainerLogs(request *restful.Request, response *restful.Response) {
podNamespace := request.PathParameter("podNamespace")
podID := request.PathParameter("podID")
containerName := request.PathParameter("containerName")
if len(podID) == 0 {
// TODO: Why return JSON when the rest return plaintext errors?
response.WriteError(http.StatusBadRequest, fmt.Errorf(`{"message": "Missing podID."}`))
return
}
if len(containerName) == 0 {
// TODO: Why return JSON when the rest return plaintext errors?
response.WriteError(http.StatusBadRequest, fmt.Errorf(`{"message": "Missing container name."}`))
return
}
if len(podNamespace) == 0 {
// TODO: Why return JSON when the rest return plaintext errors?
response.WriteError(http.StatusBadRequest, fmt.Errorf(`{"message": "Missing podNamespace."}`))
return
}
follow, _ := strconv.ParseBool(request.QueryParameter("follow"))
previous, _ := strconv.ParseBool(request.QueryParameter("previous"))
tail := request.QueryParameter("tail")
pod, ok := s.host.GetPodByName(podNamespace, podID)
if !ok {
response.WriteError(http.StatusNotFound, fmt.Errorf("Pod %q does not exist", podID))
return
}
// Check if containerName is valid.
containerExists := false
for _, container := range pod.Spec.Containers {
if container.Name == containerName {
containerExists = true
}
}
if !containerExists {
response.WriteError(http.StatusNotFound, fmt.Errorf("Container %q not found in Pod %q", containerName, podID))
return
}
if _, ok := response.ResponseWriter.(http.Flusher); !ok {
response.WriteError(http.StatusInternalServerError, fmt.Errorf("unable to convert %v into http.Flusher", response))
return
}
fw := flushwriter.Wrap(response)
response.Header().Set("Transfer-Encoding", "chunked")
response.WriteHeader(http.StatusOK)
err := s.host.GetKubeletContainerLogs(kubecontainer.GetPodFullName(pod), containerName, tail, follow, previous, fw, fw)
if err != nil {
response.WriteError(http.StatusInternalServerError, err)
return
}
}
// Derived from go-restful writeJSON.
func writeJsonResponse(response *restful.Response, data []byte) {
if data == nil {
response.WriteHeader(http.StatusOK)
// do not write a nil representation
return
}
response.Header().Set(restful.HEADER_ContentType, restful.MIME_JSON)
response.WriteHeader(http.StatusOK)
if _, err := response.Write(data); err != nil {
glog.Errorf("Error writing response: %v", err)
}
}
// Handles delete Replication Controller API call.
func (apiHandler *ApiHandler) handleDeleteReplicationController(
request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
replicationController := request.PathParameter("replicationController")
if err := DeleteReplicationControllerWithPods(apiHandler.client, namespace, replicationController); err != nil {
handleInternalError(response, err)
return
}
response.WriteHeader(http.StatusOK)
}
func (apiHandler *ApiHandler) handleDeleteResource(
request *restful.Request, response *restful.Response) {
kind := request.PathParameter("kind")
namespace := request.PathParameter("namespace")
name := request.PathParameter("name")
if err := apiHandler.verber.Delete(kind, namespace, name); err != nil {
handleInternalError(response, err)
return
}
response.WriteHeader(http.StatusOK)
}
func (apiHandler *ApiHandler) handlePutResource(
request *restful.Request, response *restful.Response) {
kind := request.PathParameter("kind")
namespace := request.PathParameter("namespace")
name := request.PathParameter("name")
putSpec := &runtime.Unknown{}
if err := request.ReadEntity(putSpec); err != nil {
handleInternalError(response, err)
return
}
if err := apiHandler.verber.Put(kind, namespace, name, putSpec); err != nil {
handleInternalError(response, err)
return
}
response.WriteHeader(http.StatusOK)
}
// Handles delete Replication Controller API call.
// TODO(floreks): there has to be some kind of transaction here
func (apiHandler *ApiHandler) handleDeleteReplicationController(
request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
replicationController := request.PathParameter("replicationController")
deleteServices, err := strconv.ParseBool(request.QueryParameter("deleteServices"))
if err != nil {
handleInternalError(response, err)
return
}
if err := DeleteReplicationController(apiHandler.client, namespace,
replicationController, deleteServices); err != nil {
handleInternalError(response, err)
return
}
response.WriteHeader(http.StatusOK)
}
// Handles delete Daemon Set API call.
func (apiHandler *ApiHandler) handleDeleteDaemonSet(
request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
daemonSet := request.PathParameter("daemonSet")
deleteServices, err := strconv.ParseBool(request.QueryParameter("deleteServices"))
if err != nil {
handleInternalError(response, err)
return
}
if err := daemonset.DeleteDaemonSet(apiHandler.client, namespace,
daemonSet, deleteServices); err != nil {
handleInternalError(response, err)
return
}
response.WriteHeader(http.StatusOK)
}
// Handles update of Replication Controller pods update API call.
func (apiHandler *ApiHandler) handleUpdateReplicasCount(
request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
replicationControllerName := request.PathParameter("replicationController")
replicationControllerSpec := new(ReplicationControllerSpec)
if err := request.ReadEntity(replicationControllerSpec); err != nil {
handleInternalError(response, err)
return
}
if err := UpdateReplicasCount(apiHandler.client, namespace, replicationControllerName,
replicationControllerSpec); err != nil {
handleInternalError(response, err)
return
}
response.WriteHeader(http.StatusAccepted)
}
// getContainerLogs handles containerLogs request against the Kubelet
func (s *Server) getContainerLogs(request *restful.Request, response *restful.Response) {
podNamespace := request.PathParameter("podNamespace")
podID := request.PathParameter("podID")
containerName := request.PathParameter("containerName")
if len(podID) == 0 {
// TODO: Why return JSON when the rest return plaintext errors?
// TODO: Why return plaintext errors?
response.WriteError(http.StatusBadRequest, fmt.Errorf(`{"message": "Missing podID."}`))
return
}
if len(containerName) == 0 {
// TODO: Why return JSON when the rest return plaintext errors?
response.WriteError(http.StatusBadRequest, fmt.Errorf(`{"message": "Missing container name."}`))
return
}
if len(podNamespace) == 0 {
// TODO: Why return JSON when the rest return plaintext errors?
response.WriteError(http.StatusBadRequest, fmt.Errorf(`{"message": "Missing podNamespace."}`))
return
}
query := request.Request.URL.Query()
// backwards compatibility for the "tail" query parameter
if tail := request.QueryParameter("tail"); len(tail) > 0 {
query["tailLines"] = []string{tail}
// "all" is the same as omitting tail
if tail == "all" {
delete(query, "tailLines")
}
}
// container logs on the kubelet are locked to v1
versioned := &v1.PodLogOptions{}
if err := api.Scheme.Convert(&query, versioned); err != nil {
response.WriteError(http.StatusBadRequest, fmt.Errorf(`{"message": "Unable to decode query."}`))
return
}
out, err := api.Scheme.ConvertToVersion(versioned, "")
if err != nil {
response.WriteError(http.StatusBadRequest, fmt.Errorf(`{"message": "Unable to convert request query."}`))
return
}
logOptions := out.(*api.PodLogOptions)
logOptions.TypeMeta = unversioned.TypeMeta{}
if errs := validation.ValidatePodLogOptions(logOptions); len(errs) > 0 {
response.WriteError(apierrs.StatusUnprocessableEntity, fmt.Errorf(`{"message": "Invalid request."}`))
return
}
pod, ok := s.host.GetPodByName(podNamespace, podID)
if !ok {
response.WriteError(http.StatusNotFound, fmt.Errorf("Pod %q does not exist", podID))
return
}
// Check if containerName is valid.
containerExists := false
for _, container := range pod.Spec.Containers {
if container.Name == containerName {
containerExists = true
}
}
if !containerExists {
response.WriteError(http.StatusNotFound, fmt.Errorf("Container %q not found in Pod %q", containerName, podID))
return
}
if _, ok := response.ResponseWriter.(http.Flusher); !ok {
response.WriteError(http.StatusInternalServerError, fmt.Errorf("unable to convert %v into http.Flusher", response))
return
}
fw := flushwriter.Wrap(response.ResponseWriter)
if logOptions.LimitBytes != nil {
fw = limitwriter.New(fw, *logOptions.LimitBytes)
}
response.Header().Set("Transfer-Encoding", "chunked")
response.WriteHeader(http.StatusOK)
if err := s.host.GetKubeletContainerLogs(kubecontainer.GetPodFullName(pod), containerName, logOptions, fw, fw); err != nil {
if err != limitwriter.ErrMaximumWrite {
response.WriteError(http.StatusInternalServerError, err)
}
return
}
}