http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupHealth.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupHealth.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupHealth.java new file mode 100644 index 0000000..0994b53 --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupHealth.java @@ -0,0 +1,105 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.rpg; + +public class RemoteProcessGroupHealth implements java.io.Serializable { + private String transmissionStatus; + private boolean hasBulletins; + private boolean hasAuthorizationIssues; + private int activePortCount; + private int inactivePortCount; + + public RemoteProcessGroupHealth() { + } + + public String getTransmissionStatus() { + return transmissionStatus; + } + + public void setTransmissionStatus(String transmissionStatus) { + this.transmissionStatus = transmissionStatus; + } + + public boolean isHasBulletins() { + return hasBulletins; + } + + public void setHasBulletins(boolean hasBulletins) { + this.hasBulletins = hasBulletins; + } + + public boolean isHasAuthorizationIssues() { + return hasAuthorizationIssues; + } + + public void setHasAuthorizationIssues(boolean hasAuthorizationIssues) { + this.hasAuthorizationIssues = hasAuthorizationIssues; + } + + public int getActivePortCount() { + return activePortCount; + } + + public void setActivePortCount(int activePortCount) { + this.activePortCount = activePortCount; + } + + public int getInactivePortCount() { + return inactivePortCount; + } + + public void setInactivePortCount(int inactivePortCount) { + this.inactivePortCount = inactivePortCount; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + RemoteProcessGroupHealth that = (RemoteProcessGroupHealth) o; + + if (isHasBulletins() != that.isHasBulletins()) return false; + if (isHasAuthorizationIssues() != that.isHasAuthorizationIssues()) return false; + if (getActivePortCount() != that.getActivePortCount()) return false; + if (getInactivePortCount() != that.getInactivePortCount()) return false; + return getTransmissionStatus() != null ? getTransmissionStatus().equals(that.getTransmissionStatus()) : that.getTransmissionStatus() == null; + + } + + @Override + public int hashCode() { + int result = getTransmissionStatus() != null ? getTransmissionStatus().hashCode() : 0; + result = 31 * result + (isHasBulletins() ? 1 : 0); + result = 31 * result + (isHasAuthorizationIssues() ? 1 : 0); + result = 31 * result + getActivePortCount(); + result = 31 * result + getInactivePortCount(); + return result; + } + + @Override + public String toString() { + return "{" + + "transmissionStatus='" + transmissionStatus + '\'' + + ", hasBulletins=" + hasBulletins + + ", hasAuthorizationIssues=" + hasAuthorizationIssues + + ", activePortCount=" + activePortCount + + ", inactivePortCount=" + inactivePortCount + + '}'; + } +}
http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupStats.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupStats.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupStats.java new file mode 100644 index 0000000..72e7074 --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupStats.java @@ -0,0 +1,81 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.rpg; + +public class RemoteProcessGroupStats implements java.io.Serializable { + private int activeThreads; + private int sentCount; + private long sentContentSize; + + public RemoteProcessGroupStats() { + } + + public int getActiveThreads() { + return activeThreads; + } + + public void setActiveThreads(int activeThreads) { + this.activeThreads = activeThreads; + } + + public int getSentCount() { + return sentCount; + } + + public void setSentCount(int sentCount) { + this.sentCount = sentCount; + } + + public long getSentContentSize() { + return sentContentSize; + } + + public void setSentContentSize(long sentContentSize) { + this.sentContentSize = sentContentSize; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + RemoteProcessGroupStats that = (RemoteProcessGroupStats) o; + + if (getActiveThreads() != that.getActiveThreads()) return false; + if (getSentCount() != that.getSentCount()) return false; + return getSentContentSize() == that.getSentContentSize(); + + } + + @Override + public int hashCode() { + int result = getActiveThreads(); + result = 31 * result + getSentCount(); + result = 31 * result + (int) (getSentContentSize() ^ (getSentContentSize() >>> 32)); + return result; + } + + @Override + public String toString() { + return "{" + + "activeThreads=" + activeThreads + + ", sentCount=" + sentCount + + ", sentContentSize=" + sentContentSize + + '}'; + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupStatusBean.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupStatusBean.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupStatusBean.java new file mode 100644 index 0000000..b4ee5ce --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/rpg/RemoteProcessGroupStatusBean.java @@ -0,0 +1,121 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.rpg; + +import org.apache.nifi.minifi.commons.status.common.BulletinStatus; + +import java.util.List; + +public class RemoteProcessGroupStatusBean implements java.io.Serializable { + private String name; + private RemoteProcessGroupHealth remoteProcessGroupHealth; + private List<BulletinStatus> bulletinList; + private List<String> authorizationIssues; + private List<InputPortStatus> inputPortStatusList; + private RemoteProcessGroupStats remoteProcessGroupStats; + + public RemoteProcessGroupStatusBean() { + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public RemoteProcessGroupHealth getRemoteProcessGroupHealth() { + return remoteProcessGroupHealth; + } + + public void setRemoteProcessGroupHealth(RemoteProcessGroupHealth remoteProcessGroupHealth) { + this.remoteProcessGroupHealth = remoteProcessGroupHealth; + } + + public List<BulletinStatus> getBulletinList() { + return bulletinList; + } + + public void setBulletinList(List<BulletinStatus> bulletinList) { + this.bulletinList = bulletinList; + } + + public List<String> getAuthorizationIssues() { + return authorizationIssues; + } + + public void setAuthorizationIssues(List<String> authorizationIssues) { + this.authorizationIssues = authorizationIssues; + } + + public List<InputPortStatus> getInputPortStatusList() { + return inputPortStatusList; + } + + public void setInputPortStatusList(List<InputPortStatus> inputPortStatusList) { + this.inputPortStatusList = inputPortStatusList; + } + + public RemoteProcessGroupStats getRemoteProcessGroupStats() { + return remoteProcessGroupStats; + } + + public void setRemoteProcessGroupStats(RemoteProcessGroupStats remoteProcessGroupStats) { + this.remoteProcessGroupStats = remoteProcessGroupStats; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + RemoteProcessGroupStatusBean that = (RemoteProcessGroupStatusBean) o; + + if (getName() != null ? !getName().equals(that.getName()) : that.getName() != null) return false; + if (getRemoteProcessGroupHealth() != null ? !getRemoteProcessGroupHealth().equals(that.getRemoteProcessGroupHealth()) : that.getRemoteProcessGroupHealth() != null) return false; + if (getBulletinList() != null ? !getBulletinList().equals(that.getBulletinList()) : that.getBulletinList() != null) return false; + if (getAuthorizationIssues() != null ? !getAuthorizationIssues().equals(that.getAuthorizationIssues()) : that.getAuthorizationIssues() != null) return false; + if (getInputPortStatusList() != null ? !getInputPortStatusList().equals(that.getInputPortStatusList()) : that.getInputPortStatusList() != null) return false; + return getRemoteProcessGroupStats() != null ? getRemoteProcessGroupStats().equals(that.getRemoteProcessGroupStats()) : that.getRemoteProcessGroupStats() == null; + + } + + @Override + public int hashCode() { + int result = getName() != null ? getName().hashCode() : 0; + result = 31 * result + (getRemoteProcessGroupHealth() != null ? getRemoteProcessGroupHealth().hashCode() : 0); + result = 31 * result + (getBulletinList() != null ? getBulletinList().hashCode() : 0); + result = 31 * result + (getAuthorizationIssues() != null ? getAuthorizationIssues().hashCode() : 0); + result = 31 * result + (getInputPortStatusList() != null ? getInputPortStatusList().hashCode() : 0); + result = 31 * result + (getRemoteProcessGroupStats() != null ? getRemoteProcessGroupStats().hashCode() : 0); + return result; + } + + @Override + public String toString() { + return "{" + + "name='" + name + '\'' + + ", remoteProcessGroupHealth=" + remoteProcessGroupHealth + + ", bulletinList=" + bulletinList + + ", authorizationIssues=" + authorizationIssues + + ", inputPortStatusList=" + inputPortStatusList + + ", remoteProcessGroupStats=" + remoteProcessGroupStats + + '}'; + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/ContentRepositoryUsage.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/ContentRepositoryUsage.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/ContentRepositoryUsage.java new file mode 100644 index 0000000..a278974 --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/ContentRepositoryUsage.java @@ -0,0 +1,107 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.system; + +public class ContentRepositoryUsage implements java.io.Serializable { + + private String name; + private long freeSpace; + private long totalSpace; + private long usedSpace; + private int diskUtilization; + + public ContentRepositoryUsage() { + + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public long getFreeSpace() { + return freeSpace; + } + + public void setFreeSpace(long freeSpace) { + this.freeSpace = freeSpace; + } + + public long getTotalSpace() { + return totalSpace; + } + + public void setTotalSpace(long totalSpace) { + this.totalSpace = totalSpace; + } + + public long getUsedSpace() { + return usedSpace; + } + + public void setUsedSpace(long usedSpace) { + this.usedSpace = usedSpace; + } + + public int getDiskUtilization() { + return diskUtilization; + } + + public void setDiskUtilization(int diskUtilization) { + this.diskUtilization = diskUtilization; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + ContentRepositoryUsage that = (ContentRepositoryUsage) o; + + if (getFreeSpace() != that.getFreeSpace()) return false; + if (getTotalSpace() != that.getTotalSpace()) return false; + if (getUsedSpace() != that.getUsedSpace()) return false; + if (getDiskUtilization() != that.getDiskUtilization()) return false; + return getName() != null ? getName().equals(that.getName()) : that.getName() == null; + + } + + @Override + public int hashCode() { + int result = getName() != null ? getName().hashCode() : 0; + result = 31 * result + (int) (getFreeSpace() ^ (getFreeSpace() >>> 32)); + result = 31 * result + (int) (getTotalSpace() ^ (getTotalSpace() >>> 32)); + result = 31 * result + (int) (getUsedSpace() ^ (getUsedSpace() >>> 32)); + result = 31 * result + getDiskUtilization(); + return result; + } + + @Override + public String toString() { + return "{" + + "name='" + name + '\'' + + ", freeSpace=" + freeSpace + + ", totalSpace=" + totalSpace + + ", usedSpace=" + usedSpace + + ", diskUtilization=" + diskUtilization + + '}'; + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/FlowfileRepositoryUsage.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/FlowfileRepositoryUsage.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/FlowfileRepositoryUsage.java new file mode 100644 index 0000000..2f6474e --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/FlowfileRepositoryUsage.java @@ -0,0 +1,94 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.system; + +public class FlowfileRepositoryUsage implements java.io.Serializable { + + private long freeSpace; + private long totalSpace; + private long usedSpace; + private int diskUtilization; + + public FlowfileRepositoryUsage() { + } + + public long getFreeSpace() { + return freeSpace; + } + + public void setFreeSpace(long freeSpace) { + this.freeSpace = freeSpace; + } + + public long getTotalSpace() { + return totalSpace; + } + + public void setTotalSpace(long totalSpace) { + this.totalSpace = totalSpace; + } + + public long getUsedSpace() { + return usedSpace; + } + + public void setUsedSpace(long usedSpace) { + this.usedSpace = usedSpace; + } + + public int getDiskUtilization() { + return diskUtilization; + } + + public void setDiskUtilization(int diskUtilization) { + this.diskUtilization = diskUtilization; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + FlowfileRepositoryUsage that = (FlowfileRepositoryUsage) o; + + if (getFreeSpace() != that.getFreeSpace()) return false; + if (getTotalSpace() != that.getTotalSpace()) return false; + if (getUsedSpace() != that.getUsedSpace()) return false; + return getDiskUtilization() == that.getDiskUtilization(); + + } + + @Override + public int hashCode() { + int result = (int) (getFreeSpace() ^ (getFreeSpace() >>> 32)); + result = 31 * result + (int) (getTotalSpace() ^ (getTotalSpace() >>> 32)); + result = 31 * result + (int) (getUsedSpace() ^ (getUsedSpace() >>> 32)); + result = 31 * result + getDiskUtilization(); + return result; + } + + @Override + public String toString() { + return "{" + + "freeSpace=" + freeSpace + + ", totalSpace=" + totalSpace + + ", usedSpace=" + usedSpace + + ", diskUtilization=" + diskUtilization + + '}'; + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/GarbageCollectionStatus.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/GarbageCollectionStatus.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/GarbageCollectionStatus.java new file mode 100644 index 0000000..0166ade --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/GarbageCollectionStatus.java @@ -0,0 +1,82 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.system; + +public class GarbageCollectionStatus implements java.io.Serializable { + + private String name; + private long collectionCount; + private long collectionTime; + + public GarbageCollectionStatus() { + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public long getCollectionCount() { + return collectionCount; + } + + public void setCollectionCount(long collectionCount) { + this.collectionCount = collectionCount; + } + + public long getCollectionTime() { + return collectionTime; + } + + public void setCollectionTime(long collectionTime) { + this.collectionTime = collectionTime; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + GarbageCollectionStatus that = (GarbageCollectionStatus) o; + + if (getCollectionCount() != that.getCollectionCount()) return false; + if (getCollectionTime() != that.getCollectionTime()) return false; + return getName() != null ? getName().equals(that.getName()) : that.getName() == null; + + } + + @Override + public int hashCode() { + int result = getName() != null ? getName().hashCode() : 0; + result = 31 * result + (int) (getCollectionCount() ^ (getCollectionCount() >>> 32)); + result = 31 * result + (int) (getCollectionTime() ^ (getCollectionTime() >>> 32)); + return result; + } + + @Override + public String toString() { + return "{" + + "name='" + name + '\'' + + ", collectionCount=" + collectionCount + + ", collectionTime=" + collectionTime + + '}'; + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/HeapStatus.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/HeapStatus.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/HeapStatus.java new file mode 100644 index 0000000..95debfe --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/HeapStatus.java @@ -0,0 +1,166 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.system; + +public class HeapStatus implements java.io.Serializable { + + private long totalHeap; + private long maxHeap; + private long freeHeap; + private long usedHeap; + private int heapUtilization; + private long totalNonHeap; + private long maxNonHeap; + private long freeNonHeap; + private long usedNonHeap; + private int nonHeapUtilization; + + public HeapStatus() { + } + + public long getTotalHeap() { + return totalHeap; + } + + public void setTotalHeap(long totalHeap) { + this.totalHeap = totalHeap; + } + + public long getMaxHeap() { + return maxHeap; + } + + public void setMaxHeap(long maxHeap) { + this.maxHeap = maxHeap; + } + + public long getFreeHeap() { + return freeHeap; + } + + public void setFreeHeap(long freeHeap) { + this.freeHeap = freeHeap; + } + + public long getUsedHeap() { + return usedHeap; + } + + public void setUsedHeap(long usedHeap) { + this.usedHeap = usedHeap; + } + + public int getHeapUtilization() { + return heapUtilization; + } + + public void setHeapUtilization(int heapUtilization) { + this.heapUtilization = heapUtilization; + } + + public long getTotalNonHeap() { + return totalNonHeap; + } + + public void setTotalNonHeap(long totalNonHeap) { + this.totalNonHeap = totalNonHeap; + } + + public long getMaxNonHeap() { + return maxNonHeap; + } + + public void setMaxNonHeap(long maxNonHeap) { + this.maxNonHeap = maxNonHeap; + } + + public long getFreeNonHeap() { + return freeNonHeap; + } + + public void setFreeNonHeap(long freeNonHeap) { + this.freeNonHeap = freeNonHeap; + } + + public long getUsedNonHeap() { + return usedNonHeap; + } + + public void setUsedNonHeap(long usedNonHeap) { + this.usedNonHeap = usedNonHeap; + } + + public int getNonHeapUtilization() { + return nonHeapUtilization; + } + + public void setNonHeapUtilization(int nonHeapUtilization) { + this.nonHeapUtilization = nonHeapUtilization; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + HeapStatus that = (HeapStatus) o; + + if (getTotalHeap() != that.getTotalHeap()) return false; + if (getMaxHeap() != that.getMaxHeap()) return false; + if (getFreeHeap() != that.getFreeHeap()) return false; + if (getUsedHeap() != that.getUsedHeap()) return false; + if (getHeapUtilization() != that.getHeapUtilization()) return false; + if (getTotalNonHeap() != that.getTotalNonHeap()) return false; + if (getMaxNonHeap() != that.getMaxNonHeap()) return false; + if (getFreeNonHeap() != that.getFreeNonHeap()) return false; + if (getUsedNonHeap() != that.getUsedNonHeap()) return false; + return getNonHeapUtilization() == that.getNonHeapUtilization(); + + } + + @Override + public int hashCode() { + int result = (int) (getTotalHeap() ^ (getTotalHeap() >>> 32)); + result = 31 * result + (int) (getMaxHeap() ^ (getMaxHeap() >>> 32)); + result = 31 * result + (int) (getFreeHeap() ^ (getFreeHeap() >>> 32)); + result = 31 * result + (int) (getUsedHeap() ^ (getUsedHeap() >>> 32)); + result = 31 * result + getHeapUtilization(); + result = 31 * result + (int) (getTotalNonHeap() ^ (getTotalNonHeap() >>> 32)); + result = 31 * result + (int) (getMaxNonHeap() ^ (getMaxNonHeap() >>> 32)); + result = 31 * result + (int) (getFreeNonHeap() ^ (getFreeNonHeap() >>> 32)); + result = 31 * result + (int) (getUsedNonHeap() ^ (getUsedNonHeap() >>> 32)); + result = 31 * result + getNonHeapUtilization(); + return result; + } + + @Override + public String toString() { + return "{" + + "totalHeap=" + totalHeap + + ", maxHeap=" + maxHeap + + ", freeHeap=" + freeHeap + + ", usedHeap=" + usedHeap + + ", heapUtilization=" + heapUtilization + + ", totalNonHeap=" + totalNonHeap + + ", maxNonHeap=" + maxNonHeap + + ", freeNonHeap=" + freeNonHeap + + ", usedNonHeap=" + usedNonHeap + + ", nonHeapUtilization=" + nonHeapUtilization + + '}'; + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/SystemDiagnosticsStatus.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/SystemDiagnosticsStatus.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/SystemDiagnosticsStatus.java new file mode 100644 index 0000000..4f3892f --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/SystemDiagnosticsStatus.java @@ -0,0 +1,107 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.system; + +import java.util.List; + +public class SystemDiagnosticsStatus implements java.io.Serializable { + private List<GarbageCollectionStatus> garbageCollectionStatusList; + private HeapStatus heapStatus; + private SystemProcessorStats systemProcessorStats; + private List<ContentRepositoryUsage> contentRepositoryUsageList; + private FlowfileRepositoryUsage flowfileRepositoryUsage; + + public SystemDiagnosticsStatus() { + } + + public List<GarbageCollectionStatus> getGarbageCollectionStatusList() { + return garbageCollectionStatusList; + } + + public void setGarbageCollectionStatusList(List<GarbageCollectionStatus> garbageCollectionStatusList) { + this.garbageCollectionStatusList = garbageCollectionStatusList; + } + + public HeapStatus getHeapStatus() { + return heapStatus; + } + + public void setHeapStatus(HeapStatus heapStatus) { + this.heapStatus = heapStatus; + } + + public SystemProcessorStats getProcessorStatus() { + return systemProcessorStats; + } + + public void setProcessorStatus(SystemProcessorStats processorStatus) { + this.systemProcessorStats = processorStatus; + } + + public List<ContentRepositoryUsage> getContentRepositoryUsageList() { + return contentRepositoryUsageList; + } + + public void setContentRepositoryUsageList(List<ContentRepositoryUsage> contentRepositoryUsageList) { + this.contentRepositoryUsageList = contentRepositoryUsageList; + } + + public FlowfileRepositoryUsage getFlowfileRepositoryUsage() { + return flowfileRepositoryUsage; + } + + public void setFlowfileRepositoryUsage(FlowfileRepositoryUsage flowfileRepositoryUsage) { + this.flowfileRepositoryUsage = flowfileRepositoryUsage; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + SystemDiagnosticsStatus that = (SystemDiagnosticsStatus) o; + + if (getGarbageCollectionStatusList() != null ? !getGarbageCollectionStatusList().equals(that.getGarbageCollectionStatusList()) : that.getGarbageCollectionStatusList() != null) return false; + if (getHeapStatus() != null ? !getHeapStatus().equals(that.getHeapStatus()) : that.getHeapStatus() != null) return false; + if (systemProcessorStats != null ? !systemProcessorStats.equals(that.systemProcessorStats) : that.systemProcessorStats != null) return false; + if (getContentRepositoryUsageList() != null ? !getContentRepositoryUsageList().equals(that.getContentRepositoryUsageList()) : that.getContentRepositoryUsageList() != null) return false; + return getFlowfileRepositoryUsage() != null ? getFlowfileRepositoryUsage().equals(that.getFlowfileRepositoryUsage()) : that.getFlowfileRepositoryUsage() == null; + + } + + @Override + public int hashCode() { + int result = getGarbageCollectionStatusList() != null ? getGarbageCollectionStatusList().hashCode() : 0; + result = 31 * result + (getHeapStatus() != null ? getHeapStatus().hashCode() : 0); + result = 31 * result + (systemProcessorStats != null ? systemProcessorStats.hashCode() : 0); + result = 31 * result + (getContentRepositoryUsageList() != null ? getContentRepositoryUsageList().hashCode() : 0); + result = 31 * result + (getFlowfileRepositoryUsage() != null ? getFlowfileRepositoryUsage().hashCode() : 0); + return result; + } + + @Override + public String toString() { + return "{" + + "garbageCollectionStatusList=" + garbageCollectionStatusList + + ", heapStatus=" + heapStatus + + ", systemProcessorStats=" + systemProcessorStats + + ", contentRepositoryUsageList=" + contentRepositoryUsageList + + ", flowfileRepositoryUsage=" + flowfileRepositoryUsage + + '}'; + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/SystemProcessorStats.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/SystemProcessorStats.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/SystemProcessorStats.java new file mode 100644 index 0000000..5b0cfb3 --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/system/SystemProcessorStats.java @@ -0,0 +1,73 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.system; + +public class SystemProcessorStats implements java.io.Serializable { + + private double loadAverage; + private int availableProcessors; + + public SystemProcessorStats() { + } + + public double getLoadAverage() { + return loadAverage; + } + + public void setLoadAverage(double loadAverage) { + this.loadAverage = loadAverage; + } + + public int getAvailableProcessors() { + return availableProcessors; + } + + public void setAvailableProcessors(int availableProcessors) { + this.availableProcessors = availableProcessors; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + SystemProcessorStats that = (SystemProcessorStats) o; + + if (Double.compare(that.getLoadAverage(), getLoadAverage()) != 0) return false; + return getAvailableProcessors() == that.getAvailableProcessors(); + + } + + @Override + public int hashCode() { + int result; + long temp; + temp = Double.doubleToLongBits(getLoadAverage()); + result = (int) (temp ^ (temp >>> 32)); + result = 31 * result + getAvailableProcessors(); + return result; + } + + @Override + public String toString() { + return "{" + + "loadAverage=" + loadAverage + + ", availableProcessors=" + availableProcessors + + '}'; + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/util/StatusReportPopulator.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/util/StatusReportPopulator.java b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/util/StatusReportPopulator.java new file mode 100644 index 0000000..ff3d2cc --- /dev/null +++ b/minifi-commons/minifi-utils/src/main/java/org/apache/nifi/minifi/commons/status/util/StatusReportPopulator.java @@ -0,0 +1,375 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status.util; + +import org.apache.nifi.minifi.commons.status.FlowStatusReport; +import org.apache.nifi.minifi.commons.status.common.BulletinStatus; +import org.apache.nifi.minifi.commons.status.common.ValidationError; +import org.apache.nifi.minifi.commons.status.connection.ConnectionHealth; +import org.apache.nifi.minifi.commons.status.connection.ConnectionStats; +import org.apache.nifi.minifi.commons.status.connection.ConnectionStatusBean; +import org.apache.nifi.minifi.commons.status.controllerservice.ControllerServiceHealth; +import org.apache.nifi.minifi.commons.status.controllerservice.ControllerServiceStatus; +import org.apache.nifi.minifi.commons.status.instance.InstanceHealth; +import org.apache.nifi.minifi.commons.status.instance.InstanceStats; +import org.apache.nifi.minifi.commons.status.instance.InstanceStatus; +import org.apache.nifi.minifi.commons.status.processor.ProcessorHealth; +import org.apache.nifi.minifi.commons.status.processor.ProcessorStats; +import org.apache.nifi.minifi.commons.status.processor.ProcessorStatusBean; +import org.apache.nifi.minifi.commons.status.reportingTask.ReportingTaskHealth; +import org.apache.nifi.minifi.commons.status.reportingTask.ReportingTaskStatus; +import org.apache.nifi.minifi.commons.status.rpg.InputPortStatus; +import org.apache.nifi.minifi.commons.status.rpg.RemoteProcessGroupHealth; +import org.apache.nifi.minifi.commons.status.rpg.RemoteProcessGroupStats; +import org.apache.nifi.minifi.commons.status.rpg.RemoteProcessGroupStatusBean; +import org.apache.nifi.minifi.commons.status.system.ContentRepositoryUsage; +import org.apache.nifi.minifi.commons.status.system.FlowfileRepositoryUsage; +import org.apache.nifi.minifi.commons.status.system.GarbageCollectionStatus; +import org.apache.nifi.minifi.commons.status.system.HeapStatus; +import org.apache.nifi.minifi.commons.status.system.SystemDiagnosticsStatus; +import org.apache.nifi.minifi.commons.status.system.SystemProcessorStats; + +import java.util.Collections; +import java.util.Date; +import java.util.LinkedList; +import java.util.List; + +public class StatusReportPopulator { + private StatusReportPopulator() { + } + + public static void addProcessorStatus(FlowStatusReport flowStatusReport, boolean addHealth, boolean validationErrors, boolean addStats, boolean addBulletins, boolean populateBulletins) { + ProcessorStatusBean expectedProcessorStatus = new ProcessorStatusBean(); + expectedProcessorStatus.setName("UpdateAttributeProcessorId"); + + if (addHealth) { + ProcessorHealth processorHealth = new ProcessorHealth(); + processorHealth.setHasBulletins(populateBulletins); + processorHealth.setRunStatus("Stopped"); + if (validationErrors) { + List<ValidationError> validationErrorList = new LinkedList<>(); + ValidationError validationError1 = new ValidationError(); + validationError1.setInput("input"); + validationError1.setSubject("subject"); + validationError1.setReason("is not valid"); + validationErrorList.add(validationError1); + + ValidationError validationError2 = new ValidationError(); + validationError2.setInput("input2"); + validationError2.setSubject("subject2"); + validationError2.setReason("is not valid too"); + validationErrorList.add(validationError2); + + processorHealth.setValidationErrorList(validationErrorList); + } else { + processorHealth.setValidationErrorList(Collections.EMPTY_LIST); + } + expectedProcessorStatus.setProcessorHealth(processorHealth); + } + + if (addStats) { + ProcessorStats expectedProcessorStats = new ProcessorStats(); + + expectedProcessorStats.setActiveThreads(1); + expectedProcessorStats.setFlowfilesReceived(2); + expectedProcessorStats.setBytesRead(3); + expectedProcessorStats.setBytesWritten(4); + expectedProcessorStats.setFlowfilesSent(5); + expectedProcessorStats.setInvocations(6); + expectedProcessorStats.setProcessingNanos(7); + + expectedProcessorStatus.setProcessorStats(expectedProcessorStats); + } + + if (addBulletins) { + if (populateBulletins) { + BulletinStatus bulletinStatus = new BulletinStatus(); + bulletinStatus.setMessage("Bulletin message"); + bulletinStatus.setTimestamp(new Date(1464019245000L)); + + expectedProcessorStatus.setBulletinList(Collections.singletonList(bulletinStatus)); + } else { + expectedProcessorStatus.setBulletinList(Collections.EMPTY_LIST); + } + } + flowStatusReport.setProcessorStatusList(Collections.singletonList(expectedProcessorStatus)); + } + + public static void addConnectionStatus(FlowStatusReport flowStatusReport, boolean addHealth, boolean addStats) { + + ConnectionStatusBean expectedConnectionStatus = new ConnectionStatusBean(); + + expectedConnectionStatus.setName("connectionId"); + if (addHealth) { + ConnectionHealth connectionHealth = new ConnectionHealth(); + connectionHealth.setQueuedCount(10); + connectionHealth.setQueuedBytes(100); + expectedConnectionStatus.setConnectionHealth(connectionHealth); + } + + if (addStats) { + ConnectionStats expectedConnectionStats = new ConnectionStats(); + expectedConnectionStats.setInputCount(1); + expectedConnectionStats.setInputBytes(2); + expectedConnectionStats.setOutputCount(3); + expectedConnectionStats.setOutputBytes(4); + expectedConnectionStatus.setConnectionStats(expectedConnectionStats); + } + + flowStatusReport.setConnectionStatusList(Collections.singletonList(expectedConnectionStatus)); + } + + public static void addExpectedRemoteProcessGroupStatus(FlowStatusReport flowStatusReport, boolean addHealth, boolean addAuthorizationIssues, boolean addInputPort, + boolean addStats, boolean addBulletins, boolean populateBulletins) { + RemoteProcessGroupStatusBean expectedRemoteProcessGroupStatus = new RemoteProcessGroupStatusBean(); + expectedRemoteProcessGroupStatus.setName("rpg1"); + if (addAuthorizationIssues) { + expectedRemoteProcessGroupStatus.setAuthorizationIssues(Collections.singletonList("auth issue")); + } + + if (addHealth) { + RemoteProcessGroupHealth remoteProcessGroupHealth = new RemoteProcessGroupHealth(); + remoteProcessGroupHealth.setTransmissionStatus("Transmitting"); + remoteProcessGroupHealth.setHasBulletins(populateBulletins); + remoteProcessGroupHealth.setHasAuthorizationIssues(addAuthorizationIssues); + remoteProcessGroupHealth.setActivePortCount(1); + remoteProcessGroupHealth.setInactivePortCount(2); + expectedRemoteProcessGroupStatus.setRemoteProcessGroupHealth(remoteProcessGroupHealth); + } + + if (addBulletins) { + if (populateBulletins) { + BulletinStatus bulletinStatus = new BulletinStatus(); + bulletinStatus.setMessage("Bulletin message"); + bulletinStatus.setTimestamp(new Date(1464019245000L)); + expectedRemoteProcessGroupStatus.setBulletinList(Collections.singletonList(bulletinStatus)); + } else { + expectedRemoteProcessGroupStatus.setBulletinList(Collections.EMPTY_LIST); + } + } + + if (addInputPort) { + InputPortStatus expectedInputPortStatus = new InputPortStatus(); + expectedInputPortStatus.setName("inputPort"); + expectedInputPortStatus.setTargetExists(true); + expectedInputPortStatus.setTargetRunning(false); + expectedRemoteProcessGroupStatus.setInputPortStatusList(Collections.singletonList(expectedInputPortStatus)); + } + + if (addStats) { + RemoteProcessGroupStats remoteProcessGroupStats = new RemoteProcessGroupStats(); + remoteProcessGroupStats.setActiveThreads(3); + remoteProcessGroupStats.setSentContentSize(4L); + remoteProcessGroupStats.setSentCount(5); + expectedRemoteProcessGroupStatus.setRemoteProcessGroupStats(remoteProcessGroupStats); + } + + flowStatusReport.setRemoteProcessGroupStatusList(Collections.singletonList(expectedRemoteProcessGroupStatus)); + } + + public static void addControllerServiceStatus(FlowStatusReport flowStatusReport, boolean addHealth, boolean addValidationErrors, boolean addBulletins, boolean populateBulletins) { + ControllerServiceStatus controllerServiceStatus = new ControllerServiceStatus(); + controllerServiceStatus.setName("mockControllerService"); + + if (addBulletins) { + if (populateBulletins) { + BulletinStatus bulletinStatus = new BulletinStatus(); + bulletinStatus.setMessage("Bulletin message"); + bulletinStatus.setTimestamp(new Date(1464019245000L)); + controllerServiceStatus.setBulletinList(Collections.singletonList(bulletinStatus)); + } else { + controllerServiceStatus.setBulletinList(Collections.EMPTY_LIST); + } + } + + if (addHealth) { + ControllerServiceHealth controllerServiceHealth = new ControllerServiceHealth(); + controllerServiceHealth.setState("ENABLED"); + controllerServiceHealth.setHasBulletins(populateBulletins); + controllerServiceStatus.setControllerServiceHealth(controllerServiceHealth); + + if (addValidationErrors) { + List<ValidationError> validationErrorList = new LinkedList<>(); + ValidationError validationError1 = new ValidationError(); + validationError1.setInput("input"); + validationError1.setSubject("subject"); + validationError1.setReason("is not valid"); + validationErrorList.add(validationError1); + + ValidationError validationError2 = new ValidationError(); + validationError2.setInput("input2"); + validationError2.setSubject("subject2"); + validationError2.setReason("is not valid too"); + validationErrorList.add(validationError2); + + controllerServiceHealth.setValidationErrorList(validationErrorList); + } else { + controllerServiceHealth.setValidationErrorList(Collections.EMPTY_LIST); + } + } + + flowStatusReport.setControllerServiceStatusList(Collections.singletonList(controllerServiceStatus)); + } + + public static void addInstanceStatus(FlowStatusReport flowStatusReport, boolean addHealth, boolean addStats, boolean addBulletins, boolean populateBulletins) { + InstanceStatus instanceStatus = new InstanceStatus(); + + if (addHealth) { + InstanceHealth instanceHealth = new InstanceHealth(); + instanceHealth.setQueuedContentSize(1L); + instanceHealth.setQueuedCount(2); + instanceHealth.setActiveThreads(3); + instanceHealth.setHasBulletins(populateBulletins); + instanceStatus.setInstanceHealth(instanceHealth); + } + + if (addBulletins) { + if (populateBulletins) { + BulletinStatus bulletinStatus = new BulletinStatus(); + bulletinStatus.setMessage("Bulletin message"); + bulletinStatus.setTimestamp(new Date(1464019245000L)); + instanceStatus.setBulletinList(Collections.singletonList(bulletinStatus)); + } else { + instanceStatus.setBulletinList(Collections.EMPTY_LIST); + } + } + + if (addStats) { + InstanceStats instanceStats = new InstanceStats(); + instanceStats.setBytesRead(1L); + instanceStats.setBytesWritten(2L); + instanceStats.setBytesSent(3L); + instanceStats.setFlowfilesSent(4); + instanceStats.setBytesTransferred(5L); + instanceStats.setFlowfilesTransferred(6); + instanceStats.setBytesReceived(7L); + instanceStats.setFlowfilesReceived(8); + instanceStatus.setInstanceStats(instanceStats); + } + + flowStatusReport.setInstanceStatus(instanceStatus); + } + + public static void addSystemDiagnosticStatus(FlowStatusReport flowStatusReport, boolean addHeap, boolean addProcessorStats, boolean addFlowFileRepoUsage, boolean addContentRepoUsage, + boolean addGarbageCollectionStatus) { + + SystemDiagnosticsStatus expectedSystemDiagnosticStatus = new SystemDiagnosticsStatus(); + + if (addHeap) { + HeapStatus heapStatus = new HeapStatus(); + heapStatus.setMaxHeap(5); + heapStatus.setTotalHeap(3); + heapStatus.setUsedHeap(2); + heapStatus.setFreeHeap(1); + heapStatus.setHeapUtilization(40); + heapStatus.setMaxNonHeap(9); + heapStatus.setTotalNonHeap(8); + heapStatus.setUsedNonHeap(6); + heapStatus.setFreeNonHeap(2); + heapStatus.setNonHeapUtilization(67); + expectedSystemDiagnosticStatus.setHeapStatus(heapStatus); + } + + if (addProcessorStats) { + SystemProcessorStats systemProcessorStats = new SystemProcessorStats(); + systemProcessorStats.setLoadAverage(80.9); + systemProcessorStats.setAvailableProcessors(5); + expectedSystemDiagnosticStatus.setProcessorStatus(systemProcessorStats); + } + + if (addFlowFileRepoUsage) { + FlowfileRepositoryUsage flowfileRepositoryUsage = new FlowfileRepositoryUsage(); + flowfileRepositoryUsage.setFreeSpace(30); + flowfileRepositoryUsage.setTotalSpace(100); + flowfileRepositoryUsage.setUsedSpace(70); + flowfileRepositoryUsage.setDiskUtilization(70); + expectedSystemDiagnosticStatus.setFlowfileRepositoryUsage(flowfileRepositoryUsage); + } + + if (addContentRepoUsage) { + List<ContentRepositoryUsage> contentRepositoryUsageList = new LinkedList<>(); + ContentRepositoryUsage contentRepositoryUsage = new ContentRepositoryUsage(); + contentRepositoryUsage.setFreeSpace(30); + contentRepositoryUsage.setTotalSpace(100); + contentRepositoryUsage.setName("Content repo1"); + contentRepositoryUsage.setUsedSpace(70); + contentRepositoryUsage.setDiskUtilization(70); + contentRepositoryUsageList.add(contentRepositoryUsage); + expectedSystemDiagnosticStatus.setContentRepositoryUsageList(contentRepositoryUsageList); + } + + if (addGarbageCollectionStatus) { + List<GarbageCollectionStatus> garbageCollectionStatusList = new LinkedList<>(); + GarbageCollectionStatus garbageCollectionStatus1 = new GarbageCollectionStatus(); + garbageCollectionStatus1.setCollectionCount(1); + garbageCollectionStatus1.setCollectionTime(10); + garbageCollectionStatus1.setName("garbage 1"); + garbageCollectionStatusList.add(garbageCollectionStatus1); + expectedSystemDiagnosticStatus.setGarbageCollectionStatusList(garbageCollectionStatusList); + } + + flowStatusReport.setSystemDiagnosticsStatus(expectedSystemDiagnosticStatus); + } + + public static void addReportingTaskStatus(FlowStatusReport flowStatusReport, boolean addHealth, boolean addValidationErrors, boolean addBulletins, boolean populateBulletins) { + ReportingTaskStatus reportingTaskStatus = new ReportingTaskStatus(); + + reportingTaskStatus.setName("ReportProvenance"); + + if (addHealth) { + ReportingTaskHealth reportingTaskHealth = new ReportingTaskHealth(); + + reportingTaskHealth.setActiveThreads(1); + reportingTaskHealth.setScheduledState("RUNNING"); + reportingTaskHealth.setHasBulletins(populateBulletins); + + if (addValidationErrors) { + List<ValidationError> validationErrorList = new LinkedList<>(); + ValidationError validationError1 = new ValidationError(); + validationError1.setInput("input"); + validationError1.setSubject("subject"); + validationError1.setReason("is not valid"); + validationErrorList.add(validationError1); + + ValidationError validationError2 = new ValidationError(); + validationError2.setInput("input2"); + validationError2.setSubject("subject2"); + validationError2.setReason("is not valid too"); + validationErrorList.add(validationError2); + + reportingTaskHealth.setValidationErrorList(validationErrorList); + } else { + reportingTaskHealth.setValidationErrorList(Collections.EMPTY_LIST); + } + reportingTaskStatus.setReportingTaskHealth(reportingTaskHealth); + } + + if (addBulletins) { + if (populateBulletins) { + BulletinStatus bulletinStatus = new BulletinStatus(); + bulletinStatus.setMessage("Bulletin message"); + bulletinStatus.setTimestamp(new Date(1464019245000L)); + reportingTaskStatus.setBulletinList(Collections.singletonList(bulletinStatus)); + } else { + reportingTaskStatus.setBulletinList(Collections.EMPTY_LIST); + } + } + + flowStatusReport.setReportingTaskStatusList(Collections.singletonList(reportingTaskStatus)); + } +} http://git-wip-us.apache.org/repos/asf/nifi-minifi/blob/99820519/minifi-commons/minifi-utils/src/test/java/org/apache/nifi/minifi/commons/status/TestStatusReport.java ---------------------------------------------------------------------- diff --git a/minifi-commons/minifi-utils/src/test/java/org/apache/nifi/minifi/commons/status/TestStatusReport.java b/minifi-commons/minifi-utils/src/test/java/org/apache/nifi/minifi/commons/status/TestStatusReport.java new file mode 100644 index 0000000..fc697e3 --- /dev/null +++ b/minifi-commons/minifi-utils/src/test/java/org/apache/nifi/minifi/commons/status/TestStatusReport.java @@ -0,0 +1,88 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.nifi.minifi.commons.status; + +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.Serializable; + +import static org.apache.nifi.minifi.commons.status.util.StatusReportPopulator.addConnectionStatus; +import static org.apache.nifi.minifi.commons.status.util.StatusReportPopulator.addControllerServiceStatus; +import static org.apache.nifi.minifi.commons.status.util.StatusReportPopulator.addExpectedRemoteProcessGroupStatus; +import static org.apache.nifi.minifi.commons.status.util.StatusReportPopulator.addInstanceStatus; +import static org.apache.nifi.minifi.commons.status.util.StatusReportPopulator.addProcessorStatus; +import static org.apache.nifi.minifi.commons.status.util.StatusReportPopulator.addReportingTaskStatus; +import static org.apache.nifi.minifi.commons.status.util.StatusReportPopulator.addSystemDiagnosticStatus; +import static org.junit.Assert.assertEquals; + +public class TestStatusReport { + + @Test + public void verifySerializableFullyPopulated() throws IOException, ClassNotFoundException { + FlowStatusReport original = new FlowStatusReport(); + + addControllerServiceStatus(original, true, true, true, true); + addInstanceStatus(original, true, true, true, true); + addSystemDiagnosticStatus(original, true, true, true, true, true); + addReportingTaskStatus(original, true, true, true, true); + addConnectionStatus(original, true, true); + addProcessorStatus(original, true, true, true, true, true); + addExpectedRemoteProcessGroupStatus(original, true, true, true, true, true, true); + + byte[] byteArrayCopy = serialize(original); + FlowStatusReport copy = unSerialize(byteArrayCopy, FlowStatusReport.class); + + assertEquals(original, copy); + } + + @Test + public void verifySerializableSomeNull() throws IOException, ClassNotFoundException { + FlowStatusReport original = new FlowStatusReport(); + + addControllerServiceStatus(original, true, true, true, true); + addInstanceStatus(original, true, true, true, true); + addSystemDiagnosticStatus(original, true, true, true, true, true); + addProcessorStatus(original, true, true, true, true, true); + addExpectedRemoteProcessGroupStatus(original, true, true, true, true, true, true); + + byte[] byteArrayCopy = serialize(original); + FlowStatusReport copy = unSerialize(byteArrayCopy, FlowStatusReport.class); + + assertEquals(original, copy); + } + + private static <T extends Serializable> byte[] serialize(T obj) throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + oos.writeObject(obj); + oos.close(); + return baos.toByteArray(); + } + + private static <T extends Serializable> T unSerialize(byte[] b, Class<T> cl) throws IOException, ClassNotFoundException { + ByteArrayInputStream bais = new ByteArrayInputStream(b); + ObjectInputStream ois = new ObjectInputStream(bais); + Object o = ois.readObject(); + return cl.cast(o); + } +}
