All Downloads are FREE. Search and download functionalities are using the official Maven repository.

scouter.server.netio.service.handle.ConfigureService.scala Maven / Gradle / Ivy

There is a newer version: 2.20.0
Show newest version
/*
*  Copyright 2015 the original author or authors. 
 *  @https://github.com/scouter-project/scouter
 *
 *  Licensed under the Apache License, Version 2.0 (the "License"); 
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License. 
 *
 */

package scouter.server.netio.service.handle;

import scouter.io.DataInputX
import scouter.io.DataOutputX
import scouter.lang.pack.MapPack
import scouter.lang.pack.ObjectPack
import scouter.lang.pack.Pack
import scouter.lang.value.BlobValue
import scouter.lang.value.BooleanValue
import scouter.lang.value.MapValue
import scouter.net.RequestCmd
import scouter.net.TcpFlag
import scouter.server.Configure
import scouter.server.CounterManager
import scouter.server.core.AgentManager
import scouter.server.netio.AgentCall
import scouter.server.netio.service.anotation.ServiceHandler
import scouter.util.StringKeyLinkedMap.StringKeyLinkedEntry
import scouter.server.util.EnumerScala

class ConfigureService {

  @ServiceHandler(RequestCmd.GET_CONFIGURE_SERVER)
  def getConfigureServer(din: DataInputX, dout: DataOutputX, login: Boolean) {
    var result = new MapPack();

    result.put("configKey", Configure.getInstance().getKeyValueInfo().getList("key"));

    var config = Configure.getInstance().loadText();
    if (config == null) {
      config = "";
    }
    result.put("serverConfig", config);
    dout.writeByte(TcpFlag.HasNEXT);
    dout.writePack(result);
  }

  @ServiceHandler(RequestCmd.SET_CONFIGURE_SERVER)
  def setConfigureServer(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val param = din.readPack().asInstanceOf[MapPack];
    val setConfig = param.getText("setConfig");
    val success = Configure.getInstance().saveText(setConfig);
    if (success) {
      Configure.getInstance().reload(true);
    }
    val result = new MapPack();
    result.put("result", String.valueOf(success));
    dout.writeByte(TcpFlag.HasNEXT);
    dout.writePack(result);
  }

  @ServiceHandler(RequestCmd.GET_CONFIGURE_WAS)
  def getConfigureAgent(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val param = din.readPack().asInstanceOf[MapPack];
    val objHash = param.getInt("objHash");
    val o = AgentManager.getAgent(objHash);
    val p = AgentCall.call(o, RequestCmd.GET_CONFIGURE_WAS, param);
    if (p != null) {
      dout.writeByte(TcpFlag.HasNEXT);
      dout.writePack(p);
    }
  }

  @ServiceHandler(RequestCmd.SET_CONFIGURE_WAS)
  def setConfigureAgent(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val param = din.readPack().asInstanceOf[MapPack];
    val objHash = param.getInt("objHash");
    val o = AgentManager.getAgent(objHash);
    val p = AgentCall.call(o, RequestCmd.SET_CONFIGURE_WAS, param);
    if (p != null) {
      dout.writeByte(TcpFlag.HasNEXT);
      dout.writePack(p);
    }
  }

  @ServiceHandler(RequestCmd.LIST_CONFIGURE_WAS)
  def listConfigureWas(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val param = din.readPack().asInstanceOf[MapPack];
    val objHash = param.getInt("objHash");
    val o = AgentManager.getAgent(objHash);
    val p = AgentCall.call(o, RequestCmd.LIST_CONFIGURE_WAS, param);
    if (p != null) {
      dout.writeByte(TcpFlag.HasNEXT);
      dout.writePack(p);
    }
  }

  @ServiceHandler(RequestCmd.LIST_CONFIGURE_SERVER)
  def listConfigureServer(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val m = Configure.getInstance().getKeyValueInfo();
    val pack = new MapPack();
    pack.put("key", m.getList("key"));
    pack.put("value", m.getList("value"));
    pack.put("default", m.getList("default"));
    dout.writeByte(TcpFlag.HasNEXT);
    dout.writePack(pack);
  }

  @ServiceHandler(RequestCmd.REDEFINE_CLASSES)
  def applyConfigureAgent(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val param = din.readPack().asInstanceOf[MapPack];
    val objHash = param.getInt("objHash");

    val o = AgentManager.getAgent(objHash);
    val p = AgentCall.call(o, RequestCmd.REDEFINE_CLASSES, param);
    if (p != null) {
      dout.writeByte(TcpFlag.HasNEXT);
      dout.writePack(p);
    }
  }

  @ServiceHandler(RequestCmd.GET_XML_COUNTER)
  def getCounterXml(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val defaultXml = CounterManager.getInstance().getXmlContent();
    val customXml = CounterManager.getInstance().getXmlCustomContent();
    val p = new MapPack();
    p.put("default", new BlobValue(defaultXml));
    if (customXml != null && customXml.length > 0) {
      p.put("custom", new BlobValue(customXml));
    }
    dout.writeByte(TcpFlag.HasNEXT);
    dout.writePack(p);
  }

  @ServiceHandler(RequestCmd.DEFINE_OBJECT_TYPE)
  def defineObjectType(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val param = din.readPack().asInstanceOf[MapPack];
    val success = CounterManager.getInstance().addObjectType(param);
    dout.writeByte(TcpFlag.HasNEXT);
    dout.writeValue(new BooleanValue(success));
  }

  @ServiceHandler(RequestCmd.EDIT_OBJECT_TYPE)
  def editObjectType(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val param = din.readPack().asInstanceOf[MapPack];
    val success = CounterManager.getInstance().editObjectType(param);
    dout.writeByte(TcpFlag.HasNEXT);
    dout.writeValue(new BooleanValue(success));
  }
  
  @ServiceHandler(RequestCmd.CONFIGURE_DESC)
  def getConfigureDesc(din: DataInputX, dout: DataOutputX, login: Boolean) {
    val param = din.readPack().asInstanceOf[MapPack];
    val objHash = param.getInt("objHash");
    if (objHash == 0) {
      val p = new MapPack()
      val descMap = Configure.getInstance.getConfigureDesc();
      EnumerScala.foreach(descMap.entries(), (entry: StringKeyLinkedEntry[String]) => {
        p.put(entry.getKey(), entry.getValue())
      })
      dout.writeByte(TcpFlag.HasNEXT);
      dout.writePack(p);
    } else {
      val o = AgentManager.getAgent(objHash);
      val p = AgentCall.call(o, RequestCmd.CONFIGURE_DESC, param);
      if (p != null) {
        dout.writeByte(TcpFlag.HasNEXT);
        dout.writePack(p);
      }
    }
  }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy