public void Add(PolicyItem policy)
{
if (policy == null)
{
Logger.LogInfo(Properties.Resources.LOG_NULL_POLICY);
return;
}
if (Contains(policy.UniqueId))
{
Logger.LogInfo(string.Format(CultureInfo.InvariantCulture, Properties.Resources.LOG_DUPLICATE_POLICYID, policy.UniqueId));
return;
}
try
{
lock (PolicyCache.m_lockObject)
{
PolicyCacheManager.Instance.RegisterPolicy(policy);
m_policies[policy.UniqueId] = policy.Contents;
}
}
catch (Exception ex)
{
Logger.LogError(ex);
return;
}
}
/// <summary>
/// Creates a service agent
/// </summary>
/// <param name="policyFolder">All policies are read from this folder</param>
/// <returns></returns>
private static IPolicyEngineFactory CreatePolicyEngineAgent(string policyFolder)
{
IPolicyEngineFactory agent = new PolicyEngineFactory();
// Load up policies
DirectoryInfo dir = new DirectoryInfo(policyFolder);
foreach (FileInfo file in dir.GetFiles("*.runtimepolicy", SearchOption.TopDirectoryOnly))
{
PolicyItem item = new PolicyItem(file.Name, File.ReadAllBytes(file.FullName));
item.RestrictedTargets = new RunAt[] { RunAt.Client, RunAt.Server };
agent.PolicyCacheInstance.Add(item);
}
return agent;
}
private void AddProfile(string profileLocation)
{
try
{
if (m_factory != null)
{
Logger.LogInfo(string.Format("Adding profile from path: {0}", profileLocation));
string[] profiles = Directory.GetFiles(profileLocation, "*.runtimepolicy");
foreach (string profile in profiles)
{
byte[] contents = File.ReadAllBytes(profile);
PolicyItem pi = new PolicyItem(profile, contents);
pi.Revision = 0;
pi.RestrictedTargets = new Workshare.PolicyContent.RunAt[] { Workshare.PolicyContent.RunAt.Client };
pi.Users = new string[] { QualifiedUserName };
string fileName = Path.GetFileName(pi.UniqueId);
if (!m_bEnableReadyRedline
&& string.Compare("ReadyRedline.runtimepolicy", fileName, StringComparison.InvariantCultureIgnoreCase) == 0)
{
Logger.LogInfo("Not adding Ready Redline to policy cache.");
continue;
}
m_factory.PolicyCacheInstance.Add(pi);
Logger.LogInfo(string.Format("Profile successfully added from path: {0}", profileLocation));
}
}
}
catch (System.Exception ex)
{
Logger.LogError("AddProfile - Unable to add profiles from path: " + profileLocation);
Logger.LogError(ex);
}
}
private void AddPolicy(string policyFile)
{
if (!File.Exists(policyFile))
{
Logger.LogInfo(string.Format("Cannot find the policy file - {0}", policyFile));
return;
}
var contents = File.ReadAllBytes(policyFile);
var pi = new PolicyItem(policyFile, contents)
{
Revision = 0,
RestrictedTargets = new[] {PolicyContent.RunAt.Client},
Users = new[] {QualifiedUserName}
};
m_factory.PolicyCacheInstance.Add(pi);
}
/// <summary>
/// This method updates an existing policy (contents only - no metadata)
/// </summary>
/// <param name="uniqueId">Unique policy item id</param>
/// <param name="contents">Byte contents of the compiled policy set</param>
public void UpdateContent(string uniqueId, byte[] contents)
{
lock (PolicyCache.m_lockObject)
{
if (!Contains(uniqueId))
{
Logger.LogInfo(string.Format(CultureInfo.InvariantCulture, Properties.Resources.LOG_DUPLICATE_POLICYID, uniqueId));
return;
}
try
{
PolicyItem policy = new PolicyItem();
policy.UniqueId = uniqueId;
policy.Contents = contents;
PolicyCacheManager.Instance.UpdatePolicy(policy);
}
catch (Exception ex)
{
Logger.LogError(ex);
return;
}
m_policies[uniqueId] = contents;
}
}
public static void AddTestPolicyItem(string filePath)
{
if (!File.Exists(filePath))
{
filePath = Path.Combine(DefaultRuntimePolicyPath, filePath);
}
if (File.Exists(filePath))
{
PolicyItem item = new PolicyItem(filePath, File.ReadAllBytes(filePath));
item.RestrictedTargets = new Workshare.PolicyContent.RunAt[] { Workshare.PolicyContent.RunAt.Client };
item.Users = new string[] { string.Empty };
m_factory.PolicyCacheInstance.Add(item);
}
}
