private void KeySigParsed(MetaMessage meta)
{
byte scale = (byte)(meta.GetBytes()[1] == 0 ? ScaleType.Major : ScaleType.Minor);
OnKeySignatureParsed(KeyProviderFactory.GetKeyProvider().ConvertAccidentalCountToKeyRootPositionInOctave(
meta.GetBytes()[0], scale), scale);
}
private KeySignature ParseKeySignature(XElement attributes)
{
int key = keySignature.Key, scale = keySignature.Scale;
var attr = attributes.Element("key");
if (attr == null)
{
return(new KeySignature(key, scale));
}
var eMode = attr.Element("mode");
if (eMode != null)
{
string mode = eMode.Value;
if (mode.Equals("major", StringComparison.OrdinalIgnoreCase))
{
scale = (int)ScaleType.Major;
}
else if (mode.Equals("minor", StringComparison.OrdinalIgnoreCase))
{
scale = (int)ScaleType.Minor;
}
else
{
throw new ParserException("Error in key signature: " + mode);
}
}
else
{
scale = (int)ScaleType.Major;
}
if (int.TryParse(attr.Element("fifths")?.Value, out key))
{
key = KeyProviderFactory.GetKeyProvider().ConvertAccidentalCountToKeyRootPositionInOctave(-key, scale);
}
return(new KeySignature(key, scale));
}
public Key(string keySignature)
: this(KeyProviderFactory.GetKeyProvider().CreateKey(keySignature))
{
}
public virtual void ContextInitialized(ServletContextEvent sce)
{
try
{
string confDir = Runtime.GetProperty(KMSConfiguration.KmsConfigDir);
if (confDir == null)
{
throw new RuntimeException("System property '" + KMSConfiguration.KmsConfigDir +
"' not defined");
}
kmsConf = KMSConfiguration.GetKMSConf();
InitLogging(confDir);
Log.Info("-------------------------------------------------------------");
Log.Info(" Java runtime version : {}", Runtime.GetProperty("java.runtime.version"
));
Log.Info(" KMS Hadoop Version: " + VersionInfo.GetVersion());
Log.Info("-------------------------------------------------------------");
kmsAcls = new KMSACLs();
kmsAcls.StartReloader();
metricRegistry = new MetricRegistry();
jmxReporter = JmxReporter.ForRegistry(metricRegistry).Build();
jmxReporter.Start();
generateEEKCallsMeter = metricRegistry.Register(GenerateEekMeter, new Meter());
decryptEEKCallsMeter = metricRegistry.Register(DecryptEekMeter, new Meter());
adminCallsMeter = metricRegistry.Register(AdminCallsMeter, new Meter());
keyCallsMeter = metricRegistry.Register(KeyCallsMeter, new Meter());
invalidCallsMeter = metricRegistry.Register(InvalidCallsMeter, new Meter());
unauthorizedCallsMeter = metricRegistry.Register(UnauthorizedCallsMeter, new Meter
());
unauthenticatedCallsMeter = metricRegistry.Register(UnauthenticatedCallsMeter, new
Meter());
kmsAudit = new KMSAudit(kmsConf.GetLong(KMSConfiguration.KmsAuditAggregationWindow
, KMSConfiguration.KmsAuditAggregationWindowDefault));
// this is required for the the JMXJsonServlet to work properly.
// the JMXJsonServlet is behind the authentication filter,
// thus the '*' ACL.
sce.GetServletContext().SetAttribute(HttpServer2.ConfContextAttribute, kmsConf);
sce.GetServletContext().SetAttribute(HttpServer2.AdminsAcl, new AccessControlList
(AccessControlList.WildcardAclValue));
// intializing the KeyProvider
string providerString = kmsConf.Get(KMSConfiguration.KeyProviderUri);
if (providerString == null)
{
throw new InvalidOperationException("No KeyProvider has been defined");
}
KeyProvider keyProvider = KeyProviderFactory.Get(new URI(providerString), kmsConf
);
if (kmsConf.GetBoolean(KMSConfiguration.KeyCacheEnable, KMSConfiguration.KeyCacheEnableDefault
))
{
long keyTimeOutMillis = kmsConf.GetLong(KMSConfiguration.KeyCacheTimeoutKey, KMSConfiguration
.KeyCacheTimeoutDefault);
long currKeyTimeOutMillis = kmsConf.GetLong(KMSConfiguration.CurrKeyCacheTimeoutKey
, KMSConfiguration.CurrKeyCacheTimeoutDefault);
keyProvider = new CachingKeyProvider(keyProvider, keyTimeOutMillis, currKeyTimeOutMillis
);
}
Log.Info("Initialized KeyProvider " + keyProvider);
keyProviderCryptoExtension = KeyProviderCryptoExtension.CreateKeyProviderCryptoExtension
(keyProvider);
keyProviderCryptoExtension = new EagerKeyGeneratorKeyProviderCryptoExtension(kmsConf
, keyProviderCryptoExtension);
if (kmsConf.GetBoolean(KMSConfiguration.KeyAuthorizationEnable, KMSConfiguration.
KeyAuthorizationEnableDefault))
{
keyProviderCryptoExtension = new KeyAuthorizationKeyProvider(keyProviderCryptoExtension
, kmsAcls);
}
Log.Info("Initialized KeyProviderCryptoExtension " + keyProviderCryptoExtension);
int defaultBitlength = kmsConf.GetInt(KeyProvider.DefaultBitlengthName, KeyProvider
.DefaultBitlength);
Log.Info("Default key bitlength is {}", defaultBitlength);
Log.Info("KMS Started");
}
catch (Exception ex)
{
System.Console.Out.WriteLine();
System.Console.Out.WriteLine("ERROR: Hadoop KMS could not be started");
System.Console.Out.WriteLine();
System.Console.Out.WriteLine("REASON: " + ex.ToString());
System.Console.Out.WriteLine();
System.Console.Out.WriteLine("Stacktrace:");
System.Console.Out.WriteLine("---------------------------------------------------"
);
Runtime.PrintStackTrace(ex, System.Console.Out);
System.Console.Out.WriteLine("---------------------------------------------------"
);
System.Console.Out.WriteLine();
System.Environment.Exit(1);
}
}
/** The key usually identifies the tonic note and/or chord [Wikipedia] */
public ChordProgression SetKey(string key)
{
return(SetKey(KeyProviderFactory.GetKeyProvider().CreateKey(key)));
}
public static string CreateKeySignatureElement(int notePositionInOctave, int scale)
{
return(SignatureSubparser.KeySignatureString +
KeyProviderFactory.GetKeyProvider().CreateKeyString(notePositionInOctave, scale));
}
private void ComputeNoteValue(NoteContext noteContext, StaccatoParserContext parserContext)
{
if (noteContext.IsRest)
{
return;
}
// Adjust for Key Signature
if (DefaultNoteSettings.AdjustNotesByKeySignature)
{
if (parserContext.Key != null)
{
int keySig = KeyProviderFactory.GetKeyProvider().ConvertKeyToInt(parserContext.Key);
if ((keySig != 0) && (!noteContext.IsNatural))
{
if ((keySig <= -1) && (noteContext.NoteNumber == 11))
{
noteContext.NoteNumber = 10;
}
if ((keySig <= -2) && (noteContext.NoteNumber == 4))
{
noteContext.NoteNumber = 3;
}
if ((keySig <= -3) && (noteContext.NoteNumber == 9))
{
noteContext.NoteNumber = 8;
}
if ((keySig <= -4) && (noteContext.NoteNumber == 2))
{
noteContext.NoteNumber = 1;
}
if ((keySig <= -5) && (noteContext.NoteNumber == 7))
{
noteContext.NoteNumber = 6;
}
if ((keySig <= -6) && (noteContext.NoteNumber == 0))
{
noteContext.NoteNumber = 11; noteContext.OctaveNumber--;
}
if ((keySig <= -7) && (noteContext.NoteNumber == 5))
{
noteContext.NoteNumber = 4;
}
if ((keySig >= +1) && (noteContext.NoteNumber == 5))
{
noteContext.NoteNumber = 6;
}
if ((keySig >= +2) && (noteContext.NoteNumber == 0))
{
noteContext.NoteNumber = 1;
}
if ((keySig >= +3) && (noteContext.NoteNumber == 7))
{
noteContext.NoteNumber = 8;
}
if ((keySig >= +4) && (noteContext.NoteNumber == 2))
{
noteContext.NoteNumber = 3;
}
if ((keySig >= +5) && (noteContext.NoteNumber == 9))
{
noteContext.NoteNumber = 10;
}
if ((keySig >= +6) && (noteContext.NoteNumber == 4))
{
noteContext.NoteNumber = 5;
}
if ((keySig >= +7) && (noteContext.NoteNumber == 11))
{
noteContext.NoteNumber = 0; noteContext.OctaveNumber++;
}
}
}
}
// Compute the actual note number, based on octave and note
if (!noteContext.IsNumericNote)
{
int intNoteNumber = noteContext.OctaveNumber * 12 + noteContext.NoteNumber + noteContext.InternalInterval;
if (intNoteNumber > 127)
{
throw new ParserException(StaccatoMessages.CalculatedNoteOutOfRange + intNoteNumber);
}
noteContext.NoteNumber = (byte)intNoteNumber;
}
}
