inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-07-31 17:39:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

REPO-2626 / REPO-2878: Cleanup after merge from /repo - feature/REPO-2614_send_legacy_hb_data

Browse Source
This commit is contained in:
Ancuta Morarasu
2017-09-12 02:16:43 +03:00
parent 6d4510043d
commit a1dfc6fafe
3 changed files with 5 additions and 491 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
pom.xml
View File

@@ -96,6 +96,11 @@
<artifactId>alfresco-events</artifactId>
<version>1.2.5</version>
</dependency>
<dependency>
<groupId>org.alfresco</groupId>
<artifactId>alfresco-heartbeat-data-sender</artifactId>
<version>1.0.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.sun.mail</groupId>
<artifactId>javax.mail</artifactId>

322
src/main/java/org/alfresco/heartbeat/CommunityHBDataCollector.java
View File

@@ -1,322 +0,0 @@
/*
* #%L
* Alfresco Repository
* %%
* Copyright (C) 2005 - 2017 Alfresco Software Limited
* %%
* This file is part of the Alfresco software.
* If the software was purchased under a paid Alfresco license, the terms of
* the paid license agreement will prevail. Otherwise, the software is
* provided under the following open source license terms:
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
* #L%
*/
package org.alfresco.heartbeat;
import java.io.IOException;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.security.GeneralSecurityException;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.alfresco.heartbeat.datasender.HBData;
import org.alfresco.repo.descriptor.DescriptorDAO;
import org.alfresco.repo.dictionary.CustomModelsInfo;
import org.alfresco.repo.transaction.RetryingTransactionHelper;
import org.alfresco.repo.usage.RepoUsageComponent;
import org.alfresco.service.cmr.admin.RepoUsage;
import org.alfresco.service.cmr.dictionary.CustomModelService;
import org.alfresco.service.cmr.security.AuthorityService;
import org.alfresco.service.cmr.security.AuthorityType;
import org.alfresco.service.descriptor.Descriptor;
import org.alfresco.service.license.LicenseException;
import org.alfresco.service.transaction.TransactionService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.extensions.surf.util.Base64;
public class CommunityHBDataCollector extends HBBaseDataCollector
{
/** The logger. */
private static final Log logger = LogFactory.getLog(CommunityHBDataCollector.class);
/**
* The parameters that we expect to remain static throughout the lifetime of the repository. There is no need to
* continuously update these.
*/
private Map<String, Object> staticParameters;
/** The transaction service. */
private TransactionService transactionService;
/** DAO for current repository descriptor. */
private DescriptorDAO currentRepoDescriptorDAO;
/** DAO for current descriptor. */
private DescriptorDAO serverDescriptorDAO;
/** The authority service. */
private AuthorityService authorityService;
private RepoUsageComponent repoUsageComponent;
/** Provides information about custom models */
private CustomModelService customModelService;
public void setCurrentRepoDescriptorDAO(DescriptorDAO currentRepoDescriptorDAO)
{
this.currentRepoDescriptorDAO = currentRepoDescriptorDAO;
}
public void setServerDescriptorDAO(DescriptorDAO serverDescriptorDAO)
{
this.serverDescriptorDAO = serverDescriptorDAO;
}
public void setAuthorityService(AuthorityService authorityService)
{
this.authorityService = authorityService;
}
public void setRepoUsageComponent(RepoUsageComponent repoUsageComponent)
{
this.repoUsageComponent = repoUsageComponent;
}
public void setTransactionService(TransactionService transactionService)
{
this.transactionService = transactionService;
}
public void setCustomModelService(CustomModelService customModelService)
{
this.customModelService = customModelService;
}
@Override
public List<HBData> collectData()
{
List<HBData> collectedData = new LinkedList<>();
RetryingTransactionHelper.RetryingTransactionCallback<Void> initCallback = new RetryingTransactionHelper.RetryingTransactionCallback<Void>()
{
@Override
public Void execute() throws Throwable
{
lazyInit();
return null;
}
};
transactionService.getRetryingTransactionHelper().doInTransaction(initCallback, true);
// collect repository info data
logger.debug("Preparing repository info data...");
Map<String, Object> infoValues = new HashMap<String, Object>();
infoValues.put("repoName", this.staticParameters.get("repoName"));
infoValues.put("edition", this.staticParameters.get("edition"));
infoValues.put("versionMajor", this.staticParameters.get("versionMajor"));
infoValues.put("versionMinor", this.staticParameters.get("versionMinor"));
infoValues.put("schema", this.staticParameters.get("schema"));
HBData infoData = new HBData(
this.currentRepoDescriptorDAO.getDescriptor().getId(),
"acs.repository.info",
"1.0",
new Date(),
infoValues);
collectedData.add(infoData);
// collect repository usage (system) data
logger.debug("Preparing repository usage (system) data...");
Runtime runtime = Runtime.getRuntime();
Map<String, Object> systemUsageValues = new HashMap<String, Object>();
systemUsageValues.put("memFree", runtime.freeMemory());
systemUsageValues.put("memMax", runtime.maxMemory());
systemUsageValues.put("memTotal", runtime.totalMemory());
HBData systemUsageData = new HBData(
this.currentRepoDescriptorDAO.getDescriptor().getId(),
"acs.repository.usage.system",
"1.0",
new Date(),
systemUsageValues);
collectedData.add(systemUsageData);
// collect repository usage (model) data
logger.debug("Preparing repository usage (model) data...");
final CustomModelsInfo customModelsInfo = transactionService.getRetryingTransactionHelper().doInTransaction(
new RetryingTransactionHelper.RetryingTransactionCallback<CustomModelsInfo>()
{
public CustomModelsInfo execute()
{
return customModelService.getCustomModelsInfo();
}
}, true);
Map<String, Object> modelUsageValues = new HashMap<String, Object>();
modelUsageValues.put("numOfActiveModels", new Integer(customModelsInfo.getNumberOfActiveModels()));
modelUsageValues.put("numOfActiveTypes", new Integer(customModelsInfo.getNumberOfActiveTypes()));
modelUsageValues.put("numOfActiveAspects", new Integer(customModelsInfo.getNumberOfActiveAspects()));
HBData modelUsageData = new HBData(
this.currentRepoDescriptorDAO.getDescriptor().getId(),
"acs.repository.usage.model",
"1.0",
new Date(),
modelUsageValues);
collectedData.add(modelUsageData);
// collect repository license data
logger.debug("Preparing repository license data...");
String licenseKey = transactionService.getRetryingTransactionHelper().doInTransaction(
new RetryingTransactionHelper.RetryingTransactionCallback<String>()
{
public String execute()
{
try
{
byte[] licenseKey = currentRepoDescriptorDAO.getLicenseKey();
return licenseKey == null ? null : org.springframework.extensions.surf.util.Base64.encodeBytes(licenseKey, Base64.DONT_BREAK_LINES);
}
catch (LicenseException e)
{
// Swallow Licence Exception Here
// Don't log error: It'll be reported later and the logging fails
return null;
}
}
}, true);
Map<String, Object> licenseValues = new HashMap<String, Object>();
if (licenseKey != null)
{
licenseValues.put("licenseKey", licenseKey);
}
Long licenseMaxUsers = repoUsageComponent.getRestrictions().getUsers();
if (licenseMaxUsers != null)
{
licenseValues.put("licenseMaxUsers", licenseMaxUsers);
}
HBData licenseData = new HBData(
this.currentRepoDescriptorDAO.getDescriptor().getId(),
"acs.repository.license",
"1.0",
new Date(),
licenseValues);
collectedData.add(licenseData);
return collectedData;
}
/**
* Initializes static parameters on first invocation. Avoid doing it on construction due to bootstrap dependencies
* (e.g. patch service must have run)
*
* @throws GeneralSecurityException
* @throws IOException
*/
private synchronized void lazyInit() throws GeneralSecurityException, IOException
{
if (this.staticParameters == null)
{
this.staticParameters = new TreeMap<String, Object>();
// Load up the static parameters
final String ip = getLocalIps();
this.staticParameters.put("ip", ip);
final String uid;
final Descriptor currentRepoDescriptor = this.currentRepoDescriptorDAO.getDescriptor();
if (currentRepoDescriptor != null)
{
uid = currentRepoDescriptor.getId();
this.staticParameters.put("uid", uid);
}
else
{
uid = "Unknown";
}
final Descriptor serverDescriptor = this.serverDescriptorDAO.getDescriptor();
this.staticParameters.put("repoName", serverDescriptor.getName());
this.staticParameters.put("edition", serverDescriptor.getEdition());
this.staticParameters.put("versionMajor", serverDescriptor.getVersionMajor());
this.staticParameters.put("versionMinor", serverDescriptor.getVersionMinor());
this.staticParameters.put("schema", new Integer(serverDescriptor.getSchema()));
this.staticParameters.put("numUsers", new Integer(this.authorityService.getAllAuthoritiesInZone(
AuthorityService.ZONE_APP_DEFAULT, AuthorityType.USER).size()));
this.staticParameters.put("numGroups", new Integer(this.authorityService.getAllAuthoritiesInZone(
AuthorityService.ZONE_APP_DEFAULT, AuthorityType.GROUP).size()));
if(repoUsageComponent != null)
{
RepoUsage usage = repoUsageComponent.getUsage();
if (usage.getUsers() != null)
{
this.staticParameters.put("licenseUsers", new Long((usage.getUsers())));
}
}
}
}
/**
* Attempts to get all the local IP addresses of this machine in order to distinguish it from other nodes in the
* same network. The machine may use a static IP address in conjunction with a loopback adapter (e.g. to support
* Oracle on Windows), so the IP of the default network interface may not be enough to uniquely identify this
* machine.
*
* @return the local IP addresses, separated by the '/' character
*/
private String getLocalIps()
{
final StringBuilder ip = new StringBuilder(1024);
boolean first = true;
try
{
final Enumeration<NetworkInterface> i = NetworkInterface.getNetworkInterfaces();
while (i.hasMoreElements())
{
final NetworkInterface n = i.nextElement();
final Enumeration<InetAddress> j = n.getInetAddresses();
while (j.hasMoreElements())
{
InetAddress a = j.nextElement();
if (a.isLoopbackAddress())
{
continue;
}
if (first)
{
first = false;
}
else
{
ip.append('/');
}
ip.append(a.getHostAddress());
}
}
}
catch (final Exception e)
{
// Ignore
}
return first ? "127.0.0.1" : ip.toString();
}
}

169
src/main/java/org/alfresco/heartbeat/HBData.java
View File

@@ -1,169 +0,0 @@
/*
* #%L
* Alfresco Repository
* %%
* Copyright (C) 2005 - 2017 Alfresco Software Limited
* %%
* This file is part of the Alfresco software.
* If the software was purchased under a paid Alfresco license, the terms of
* the paid license agreement will prevail. Otherwise, the software is
* provided under the following open source license terms:
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
* #L%
*/
package org.alfresco.heartbeat;
import org.json.JSONException;
import org.json.JSONObject;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
/**
* Created by mmuller on 07/07/2017.
*/
public class HBData
{
public static String SCHEMA_VERSION = "1.0";
public static String SCHEMA_VERSION_KEY = "sv";
public static String SYSTEM_ID_KEY = "sId";
public static String COLLECTOR_ID_KEY = "cId";
public static String COLLECTOR_VERSION_KEY = "cv";
public static String TIMESTAMP_KEY = "t";
public static String DATA_KEY = "d";
private String systemId;
private String collectorId;
private String collectorVersion;
private String timestamp;
private Map<String, Object> data;
public HBData(String systemId, String collectorId, String collectorVersion, String timestamp)
{
this.systemId = systemId;
this.collectorId = collectorId;
this.collectorVersion = collectorVersion;
this.timestamp = timestamp;
}
public HBData(String systemId, String collectorId, String collectorVersion, String timestamp, Map<String, Object> data)
{
this.systemId = systemId;
this.collectorId = collectorId;
this.collectorVersion = collectorVersion;
this.timestamp = timestamp;
this.data = data;
}
public JSONObject getJSONObject() throws JSONException
{
// save data collector properties
// The LinkedHashMap was choose only because for demoing
Map<String, String> keyValues = new LinkedHashMap<String, String>();
keyValues.put(SCHEMA_VERSION_KEY, SCHEMA_VERSION);
keyValues.put(SYSTEM_ID_KEY, this.systemId);
keyValues.put(COLLECTOR_ID_KEY, this.collectorId);
keyValues.put(COLLECTOR_VERSION_KEY, this.collectorVersion);
keyValues.put(TIMESTAMP_KEY, this.timestamp);
// save collected data
JSONObject jsonObject = new JSONObject(keyValues);
jsonObject.put(DATA_KEY, new JSONObject(this.data));
return jsonObject;
}
public String getSystemId()
{
return systemId;
}
public void setSystemId(String systemId)
{
this.systemId = systemId;
}
public String getCollectorId()
{
return collectorId;
}
public void setCollectorId(String collectorId)
{
this.collectorId = collectorId;
}
public String getCollectorVersion()
{
return collectorVersion;
}
public void setCollectorVersion(String collectorVersion)
{
this.collectorVersion = collectorVersion;
}
public String getTimestamp()
{
return timestamp;
}
public void setTimestamp(String timestamp)
{
this.timestamp = timestamp;
}
public Map<String, Object> getData()
{
return data;
}
public void setData(Map<String, Object> data)
{
this.data = data;
}
@Override
public String toString()
{
return "HBData(" + systemId + " " + collectorId + " " + collectorVersion + " " + timestamp +")";
}
public static void main(String[] args) throws JSONException
{
Map<String, Object> data = new TreeMap<String, Object>();
data.put("k1","v1");
data.put("k2",new Integer(2));
data.put("k3","v3");
// ISO-8601 same as JavaScript toISOString()
String timeStamp = new SimpleDateFormat("YYYY-MM-dd'T'HH:mm:ss.sss'Z'").format(new Date());
HBData collectorData = new HBData("99db325c-13c4-4b74-8d1d-f4800b345c89",
"acs.repository.test",
"1.0",
timeStamp);
collectorData.setData(data);
String jsonString = collectorData.getJSONObject().toString();
System.out.println(":O ");
System.out.println(jsonString);
}
}