/*
* Retorna a lista de ações descritas na lista de nós XML.
*/
protected Dictionary <string, MetaAction> getActions(XmlNodeList nodes, MetaUnit unit)
{
if (nodes != null)
{
IEnumerator ienum = (IEnumerator)nodes.GetEnumerator();
Dictionary <string, MetaAction> actionList = new Dictionary <string, MetaAction>();
MetaAction action;
XmlNode actionNode;
while (ienum.MoveNext())
{
actionNode = (XmlNode)ienum.Current;
action = new MetaAction();
action.Id = generator.genId();
action.Father = unit;
action.Name = actionNode.SelectSingleNode("identifier").InnerText;
List <Transition> trans = getTransitions(actionNode.SelectSingleNode("protocol").FirstChild, unit, Configuration.INITIAL_STATE, Configuration.FINAL_STATE, 2, 0);
action.Protocol = new Configuration(numStates, trans, numTransations);
actionList.Add(action.Name, action);
}
if (actionList.Count > 0)
{
return(actionList);
}
}
return(null);
}
public void LoadComponent(string xml)
{
this.loader = new XmlLoader(the_unit);
this.application = loader.loadComponent(xml);
this.unitName = the_unit.Id_unit;
//this.index = the_unit.PartitionIndex;
foreach (MetaUnit u in application.Units.Values)
{
//Console.WriteLine("[ConfigurationManager.LoadComponent] Unit {0}", the_unit.CID.getInstanceName);
if (u.Name.Equals(this.unitName))
{
this.unit = u;
//u.Index = this.index;
break;
}
}
if (this.unit == null)
{
throw new Exception("Unit not found. Name: " + unitName);
}
ready = true;
Console.WriteLine("[ConfigurationManager.LoadComponent] Unidade {0} carregada e apta para execução.", the_unit.CID.getInstanceName());
N = the_unit.CID.getInstanceName().Equals("app.adi_solver3D-adi");
}
/*
* Método para carregar as informações das unidades a partir de um nó XML.
*/
public Dictionary <string, MetaUnit> getUnits(XmlNodeList nodes)
{
if (nodes != null)
{
IEnumerator ienum = (IEnumerator)nodes.GetEnumerator();
Dictionary <string, MetaUnit> unitList = new Dictionary <string, MetaUnit> ();
MetaUnit unit;
XmlNode unitNode;
XmlAttribute attr;
while (ienum.MoveNext())
{
unitNode = (XmlNode)ienum.Current;
unit = new MetaUnit();
unit.Id = generator.genId();
attr = (XmlAttribute)unitNode.Attributes.GetNamedItem("name");
unit.Name = attr.Value;
attr = (XmlAttribute)unitNode.Attributes.GetNamedItem("index");
if (attr != null)
{
unit.Index = Convert.ToInt32(attr.Value);
}
attr = (XmlAttribute)unitNode.Attributes.GetNamedItem("parallel");
if (attr != null)
{
unit.Parallel = attr.Value.Equals("true");
}
unit.Slices = getSlices(unitNode.SelectNodes("slice"));
unit.Actions = getActions(unitNode.SelectNodes("action"), unit);
unit.Conditions = getConditions(unitNode.SelectNodes("condition"));
//TODO nao existe mais um no com esse nome. E uma acao.
if (unitNode.SelectSingleNode("validation") != null)
{
//TODO resolver a forma de representação do validation protocol.
}
unitList.Add(unit.Name, unit);
}
if (unitList.Count > 0)
{
return(unitList);
}
}
return(null);
}
/*
* geração das transitions baseado no protocolo da ação.
*/
public List <Transition> getTransitions(XmlNode node, MetaUnit unit, int initial, int final, int numStates, int numTransations)
{
List <Transition> transitions = new List <Transition> ();
Queue <Transition> treat = new Queue <Transition> ();
//Console.WriteLine("Initial {0} | Final {1} | numStates {2} | numTrans {3}", initial, final, numStates, numTransations);
treat.Enqueue(new Transition(initial, final, node, numTransations++));
Transition t;
XmlNode pivotNode, child, guardNode;
XmlNodeList children;
XmlAttribute attr;
Condition condition;
int initialState, finalState;
bool repeat;
initialState = finalState = 0;
while (treat.Count > 0)
{
t = treat.Dequeue();
pivotNode = (XmlNode)t.Action;
t.Action = null;
transitions.Add(t);
condition = null;
attr = (XmlAttribute)pivotNode.Attributes.GetNamedItem("id");
if (attr != null)
{
t.AddId(attr.Value);
}
repeat = false;
attr = (XmlAttribute)pivotNode.Attributes.GetNamedItem("repeat");
if (attr != null)
{
repeat = attr.Value.Equals("true");
}
guardNode = pivotNode.SelectSingleNode("guard");
condition = null;
//Console.WriteLine("[XmlLoaderUtil.getTransitions] Ação a avaliar... {0}", pivotNode.Name);
if (pivotNode.Name.Equals("seq") || pivotNode.Name.Equals("par"))
{
if (guardNode != null)
{
condition = getCondition(guardNode);
Transition tElse;
initialState = numStates++;
if (condition != null) //condition nao é else.
{
transitions.Add(new Transition(t.InitialState, initialState, new ExecutionAction(null, condition), Transition.INTERNAL_TRANSITION));
tElse = new Transition(t.InitialState, t.FinalState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION);
}
else
{
tElse = new Transition(t.InitialState, initialState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION);
}
tElse.IsElse = true;
transitions.Add(tElse);
}
else
{
initialState = t.InitialState;
}
}
switch (pivotNode.Name)
{
case "seq":
children = pivotNode.ChildNodes;
for (int r = 0; r < children.Count; r++)
{
child = children.Item(r);
if (child.Name.Equals("guard"))
{
continue;
}
if (r == (children.Count - 1))
{
if (repeat)
{
finalState = t.InitialState;
}
else
{
finalState = t.FinalState;
}
}
else
{
finalState = numStates++;
}
treat.Enqueue(new Transition(initialState, finalState, child.FirstChild, numTransations++));
initialState = finalState;
}
break;
case "par":
children = pivotNode.ChildNodes;
if (repeat)
{
finalState = numStates++;
transitions.Add(new Transition(finalState, t.InitialState, Configuration.LAMBDA_TRANSITION, Transition.INTERNAL_TRANSITION));
}
else
{
finalState = t.FinalState;
}
for (int r = 0; r < children.Count; r++)
{
child = children.Item(r);
if (child.Name.Equals("guard"))
{
continue;
}
treat.Enqueue(new Transition(initialState, finalState, child.FirstChild, numTransations++));
}
break;
case "perform":
bool isElse = false;
initialState = t.InitialState;
finalState = t.FinalState;
child = pivotNode;
if (guardNode != null)
{
condition = getCondition(guardNode);
if (condition == null)
{
isElse = true;
}
}
attr = (XmlAttribute)child.Attributes.GetNamedItem("slice_id");
//Console.WriteLine("[XmlLoaderUtil.getTransitions] Avaliando ação sobre a fatia {0}", attr.Value);
string sliceName = "";
if (attr != null)
{
sliceName = attr.Value;
}
string methodName = child.Attributes.GetNamedItem("action_id").Value;
//Console.WriteLine("[XmlLoaderUtil.getTransitions] Avaliando ação {0}", methodName);
MetaAction selectedAction = null;
if (sliceName.Equals(""))
{
//Console.WriteLine("[XmlLoaderUtil.getTransitions] unit {0} | action {1}", unit.Name, methodName);
unit.Actions.TryGetValue(methodName, out selectedAction);
//Console.WriteLine("[XmlLoaderUtil.getTransitions] Action {0} encontrada? {1}",methodName, selectedAction != null);
if (selectedAction == null)
{
selectedAction = new MetaAction();
selectedAction.Id = generator.genId();
selectedAction.Name = methodName;
selectedAction.Father = unit;
unit.AddAction(methodName, selectedAction);
}
}
else
{
MetaSlice slice = null;
//Console.WriteLine("[XmlLoaderUtil.getTransitions] slice {0}", sliceName);
unit.Slices.TryGetValue(sliceName, out slice);
if (slice == null && candidateSlices != null)
{
candidateSlices.TryGetValue(sliceName, out slice);
}
if (slice != null)
{
//Console.WriteLine("[XmlLoaderUtil.getTransitions] slice {0} encontrada", sliceName);
if (slice.Unit.Actions != null)
{
foreach (MetaAction mact in slice.Unit.Actions.Values)
{
if (mact.Name.Equals(methodName))
{
selectedAction = mact;
break;
}
}
}
if (selectedAction == null)
{
selectedAction = new MetaAction();
selectedAction.Id = generator.genId();
selectedAction.Name = methodName;
selectedAction.Father = slice.Unit;
slice.Unit.AddAction(methodName, selectedAction);
}
}
}
if (selectedAction != null)
{
Transition tst = new Transition(initialState, finalState, new ExecutionAction(selectedAction, condition), numTransations++);
tst.IsElse = isElse;
transitions.Add(tst);
}
else
{
throw new Exception("Fatia inexistente nesta unidade: " + sliceName);
}
break;
default:
throw new Exception("invalid action: " + pivotNode.Name);
}
}
this.numStates = numStates;
this.numTransations = numTransations;
return(transitions);
}
/*
* Procura e retorna a fatia procurada. Ela corresponde a uma unidade de um innerComponent.
* Caso não exista, a unidade será criada, atribuída ao innerComponent e ao final retornada.
*
* Caso innerComponent citado não exista, o retorno do método será nulo.
*/
public Dictionary <string, MetaSlice> getSlices(XmlNodeList sliceNodes)
{
Dictionary <string, MetaSlice> slices = new Dictionary <string, MetaSlice> ();
List <MetaInnerComponent> innerList = new List <MetaInnerComponent>();
innerList.AddRange(innerComponents);
if (candidateInnerComponents != null)
{
innerList.AddRange(candidateInnerComponents);
}
if (sliceNodes != null)
{
MetaUnit unit = null;
MetaSlice slice = null;
string innerName, unitName;
int index;
XmlAttribute attr;
XmlNode sliceNode;
IEnumerator senum = (IEnumerator)sliceNodes.GetEnumerator();
while (senum.MoveNext())
{
sliceNode = (XmlNode)senum.Current;
attr = (XmlAttribute)sliceNode.Attributes.GetNamedItem("inner");
innerName = attr.Value;
attr = (XmlAttribute)sliceNode.Attributes.GetNamedItem("unit");
unitName = attr.Value;
attr = (XmlAttribute)sliceNode.Attributes.GetNamedItem("index");
if (attr != null)
{
index = Convert.ToInt32(attr.Value);
}
else
{
index = 0;
}
foreach (MetaInnerComponent comp in innerList)
{
if (comp.Identifier.Equals(innerName))
{
if (comp.Units != null)
{
//TODO deveria usar a indexacao do dictionary. O index pode trazer problemas.
foreach (MetaUnit u in comp.Units.Values)
{
if (u.Name.Equals(unitName) /* && u.Index.Equals (index)*/)
{
unit = u;
break;
}
}
}
if (unit == null)
{
unit = new MetaUnit();
unit.Id = generator.genId();
unit.Father = comp;
unit.Name = unitName;
unit.Index = index;
comp.AddUnit(unit.Name, unit);
}
break;
}
}
if (unit != null)
{
slice = new MetaSlice(unit);
slice.Inner = innerName;
unit = null;
}
if (slice != null)
{
slices.Add(innerName, slice);
}
else
{
throw new Exception("Erro ao carregar fatia: Inner component inexistente: " + innerName);
}
}
}
return(slices);
}
public ReconfigurationRequest loadRequest(string xml, MetaHashComponent component)
{
ReconfigurationRequest request = null;
Console.WriteLine("[XmlLoader.loadRequest] Iniciando carga de script de reconfiguração... ");
if (true /*validator.IsValid (REQUEST_XSD, xml)*/)
{
clear();
generator.setInitialCode(component.LastIdCode);
request = new ReconfigurationRequest();
XmlDocument document = new XmlDocument();
XmlNode nodeRequest, data;
document.Load(xml);
nodeRequest = document.SelectSingleNode("reconfigurationRequest");
data = nodeRequest.SelectSingleNode("targetComponent");
request.TargetComponent = data.InnerText;
//Console.WriteLine("[XmlLoader.LoadRequest] Obtendo componente alvo {0}", request.TargetComponent);
List <MetaParameter> parameterList = uLoader.getParameters(nodeRequest.SelectNodes("parameter"));
if (parameterList != null)
{
Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações estruturais...");
request.StructuralRequest = new StructuralReconfigurationRequest(parameterList);
}
BehavioralReconfigurationRequest behavioralRequest = null;
List <MetaInnerComponent> innerComponents = generateInnerComponents(nodeRequest.SelectNodes("innerComponent"));
//Console.WriteLine("[XmlLoader.LoadRequest] Tem innerComponent para adicionar? {0}", innerComponents != null);
if (innerComponents != null)
{
behavioralRequest = new BehavioralReconfigurationRequest();
Console.WriteLine("[XmlLoader.LoadRequest] Carregando novos componentes aninhados...");
//Console.WriteLine("[XmlLoader.LoadRequest] {0} InnerComponent(s) adicionado(s)", innerComponents.Count);
behavioralRequest.NewInnerComponents = innerComponents;
uLoader.CandidateInnerComponents = innerComponents;
}
uLoader.InnerComponents = innerComponents;
XmlNodeList changeActionList = nodeRequest.SelectNodes("changeAction");
if (changeActionList != null)
{
Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações comportamentais...");
IEnumerator ienum = changeActionList.GetEnumerator();
BehavioralChange change;
XmlNode changeNode;
if (behavioralRequest == null)
{
behavioralRequest = new BehavioralReconfigurationRequest();
}
XmlAttribute attr;
int initialCode;
int aditionalStates, aditionalTrans;
aditionalStates = aditionalTrans = 0;
while (ienum.MoveNext())
{
changeNode = (XmlNode)ienum.Current;
change = new BehavioralChange();
//Console.WriteLine("[XmlLoader.LoadRequest] Criando uma nova BehavioralChange");
initialCode = generator.getCurrentCode();
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("unit");
change.Unit = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Unit a sofrer alteração: {0}", change.Unit);
MetaUnit u = component.Units[change.Unit];
if (u != null)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Unit {0} encontrada!", change.Unit);
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("action");
change.Action = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Ação a sofrer alteração: {0}", change.Action);
MetaAction a = u.Actions[change.Action];
if (a != null && !a.IsNative)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Ação {0} encontrada!", change.Action);
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("type");
if (attr.Value.Equals("remove"))
{
change.Type = BehavioralChange.BehavioralChangeType.REMOVE;
}
else
{
change.Type = BehavioralChange.BehavioralChangeType.INCLUDE;
}
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("point");
change.Point = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Ponto a sofrer alteração: {0}", change.Point);
Transition t = a.Protocol.getTransition(change.Point);
if (t != null)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Ponto {0} encontrado.", change.Point);
change.NewSlices = uLoader.getSlices(changeNode.SelectNodes("slice"));
uLoader.CandidateSlices = change.NewSlices;
if (change.Type == BehavioralChange.BehavioralChangeType.INCLUDE)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Obtendo novo protocolo");
change.Transitions = uLoader.getTransitions(changeNode.SelectSingleNode("protocol").FirstChild, u, t.InitialState, t.FinalState, a.Protocol.NumStates + aditionalStates, a.Protocol.LastTransationId + aditionalTrans);
aditionalStates = uLoader.NumStates - a.Protocol.NumStates;
aditionalTrans = uLoader.NumTransations - a.Protocol.LastTransationId;
//TODO remover
//Console.WriteLine("Transações de reconfiguração");
//foreach(Transition tst in change.Transitions) {
// Console.WriteLine(tst);
//}
}
else
{
change.Transitions = new List <Transition>();
change.Transitions.Add(new Transition(t.InitialState, t.FinalState, Configuration.LAMBDA_TRANSITION, a.Protocol.LastTransationId++));
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Ponto de reconfiguração não existe: " + change.Point);
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Ação a ser alterada não existe ou nãoo é uma configuração: " + change.Action);
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Unidade da ação a ser alterada não existe: " + change.Unit);
}
change.AditionalStates = generator.getCurrentCode() - initialCode;
behavioralRequest.AddChange(change);
}
}
request.BehavioralRequest = behavioralRequest;
component.LastIdCode = generator.getCurrentCode();
}
uLoader.CandidateSlices = null;
uLoader.CandidateInnerComponents = null;
Console.WriteLine("[XmlLoader.loadRequest] Carga de script realizada com sucesso!");
return(request);
}
/*
* Realiza a avaliação de segurança conforme os parâmetros.
* Para a reconfiguração estrutural são avaliados dois critérios.
* Quais os estados que antecedem ações ligadas a unidades que:
* 1- compõe componentes que serão removidos;
* 2- possuem fatias de unidades de componentes que serão removidos.
*
*/
public static List <ExecutionStateEvaluation> Evaluate(ReconfigurationRequest request, MetaUnit unit)
{
List <ExecutionStateEvaluation> result = new List <ExecutionStateEvaluation> ();
Queue <MetaUnit> usingSlices = new Queue <MetaUnit> ();
List <int> criticalActions;
List <int> statesToStop;
List <Interval> intervals;
MetaUnit oldUnit, usingUnit;
MetaAction usingAction;
Configuration protocol;
bool find;
foreach (MetaAction action in unit.Actions.Values)
{
Console.WriteLine("[SecurityAnalyzer.Evaluate] Avaliando a ação: " + action.Father.Name + "." + action.Name);
criticalActions = new List <int> ();
statesToStop = new List <int> ();
protocol = action.Protocol;
if (protocol == null)
{
Console.WriteLine("[SecurityAnalyzer.Evaluate] Protocolo nulo");
continue;
}
find = false;
if (request.StructuralRequest != null)
{
foreach (StructuralChange change in request.StructuralRequest.Changes)
{
oldUnit = change.Old;
//Console.WriteLine ("[SecurityAnalyzer.Evaluate] Mudança estrutural: " + oldUnit.Name);
if (isChangeConcrete(change))
{
/*Verifica:
* 1- se a ação faz parte da unidade a ser removida;
* 2- se a ação faz parte da unidade que possúi uma fatia (em qualquer nível) a ser removida;
*/
for (int i = 0; i < protocol.Actions.Count; i++)
{
usingAction = protocol.Actions [i].MetaAction;
//Console.WriteLine ("[SecurityAnalyzer.Evaluate] Avaliando a ação de indice {0}", i);
if (usingAction != null && usingAction.Father != null)
{
usingSlices.Enqueue((MetaUnit)usingAction.Father);
while (!find && usingSlices.Count > 0)
{
usingUnit = usingSlices.Dequeue();
if (usingUnit.Id == oldUnit.Id)
{
find = true;
}
else
{
if (usingUnit.Slices != null && usingUnit.Slices.Count > 0)
{
foreach (MetaSlice ms in usingUnit.Slices.Values)
{
//Console.WriteLine ("Using Slice {0}", ms.Unit.Name);
usingSlices.Enqueue(ms.Unit);
}
}
}
}
}
usingSlices.Clear();
//Se esta ação pertence ou tem com fatia a unidade a ser removida, lista quais as transições onde ela está presente.
if (find)
{
criticalActions.Add(usingAction.Id);
for (int j = 0; j < protocol.Matrix.Count; j++)
{
for (int k = 0; k < protocol.Matrix[j].Count / Configuration.BASE; k++)
{
if (protocol.Matrix [j] [k * Configuration.BASE] == i)
{
statesToStop.Add(j);
}
}
}
}
find = false;
}
}
}
}
intervals = new List <Interval> ();
BehavioralReconfigurationRequest behavioralRequest = request.BehavioralRequest;
if (behavioralRequest != null && behavioralRequest.Changes != null)
{
Console.WriteLine("[SecurityAnalyzer.Evaluate] Avaliando as reconfigurações comportamentais...");
foreach (BehavioralChange change in behavioralRequest.Changes)
{
if (unit.Name.Equals(change.Unit) && action.Name.Equals(change.Action))
{
foreach (Transition transition in protocol.Transitions)
{
if (transition.Ids.Contains(change.Point))
{
statesToStop.Add(transition.InitialState);
//Rever as paradas de intervalos. Ações simples não funciona.
//intervals.Add (new Interval (transition.InitialState, transition.FinalState));
break;
}
}
}
}
}
Console.WriteLine("[SecurityAnalyzer.Evaluate] Definindo os estados críticos...");
if (statesToStop.Count > 0)
{
result.Add(new ExecutionStateEvaluation(action.Name, criticalActions, statesToStop, intervals));
}
}
if (result.Count == 0)
{
result = null;
}
return(result);
}
public static bool isDeadlockFree(List <ExecutionStateEvaluation> evaluations, MetaUnit unit)
{
//TODO escrever o método.
if (evaluations != null)
{
}
else
{
return(true);
}
return(true);
}
public StructuralChange(MetaUnit old, MetaUnit _new)
{
this.old = old;
this._new = _new;
}
protected void createConcreteUnit(MetaUnit metaUnit, string instanceName)
{
}
protected void SubstituteUnit(MetaUnit uOld, MetaUnit uNew)
{
}
