Do you believe in open-source development? Would you like to see your security system grow and learn by itself? Are you sick of paying for software license fees every year that produce little return on investment? And, would you prefer to invest in something you could sell later on to other IT security departments? If you answered yes to these questions, then this is the book for you.
Addressing the issues of fault identification and classification, Self-Healing Systems and Wireless Networks Management presents a method for identifying and classifying faults using causal reasoning―a powerful bottom up technique for deep surface and cross context correlation establishment. It explains how to employ a similarity matrix to match the user activity log and its pattern in a transformed space and discusses the development and deployment of a policy engine.
The book describes how to use this self-growing policy engine in collaboration with a scheduler and plug-in bank to generate a healing policy. This healing policy presents the solution of the direct and causal fault. The author describes how to embed the solutions of the related faults in the healing policy so that if a client faces more faults related to the previous one, they can be addressed at the client side.
Exploring prototype systems, the text defines supporting systems architectures and includes a case study of an autonomic healing-based self-management engine. It also explains how to fulfill the tasks in linear time, so that the increase in the source file size does not affect the performance of your system―making the system highly scalable for distributed self-healing systems.
This book provides valuable guidance to help you build a self-growing, self -earning, self-healing system that, after development, learns for itself about the IT security vulnerabilities of your organization and fills the holes for future breach prevention.

The biggest issue, to date, in self-healing systems is fault iden-tification and its classification; that is, to identify what is a fault and what is not? What kind of fault is it? We use the tech-niques of Casual Reasoning in order to classify the candidate faults from the fault identification process. We devise a similar-ity matrix in order to match the user activity log and its pat-tern in a transformed space. The establishment and usage of a transformed space gives us scalability and eliminates the “out-of-context” fault candidates. Once the fault candidates are rec-ognized, they are classified into an order and forwarded to the policy engine that was developed as a part of this research.
We observe that the software specifications of a software program remain constant throughout the lifecycle of software. We exploit the software specifications to generate XML format of the specifications and further convert them into XML trees. These tree structures assist us in their manipulation so that we could identify the patterns related to the fault notifications, which are forwarded through client, with the software speci-fications. Any abnormalities are enlisted in order to be for-warded to the casual reasoning section. The casual reasoning section identifies the faults and ranks the extracted regions. Every classification class has candidate matches in the plug-in bank that contains the executables related to certain faults.
After the operation of the casual reasoning section, the entire context is forwarded to the policy engine, which in collaboration with scheduler and plug-in bank generates a healing policy. The healing policy contains the solution of the fault and the faults related to that fault. We embed the solu-tions of the related faults in the healing policy so that if the client faces more faults related to the previous one, they could be dealt with at the client side.
The results obtained because of the experiments that we carried out show the evidence that the scheme proposed shows better performance than the schemes previously pro-posed. We fulfill the tasks in linear time, which means that the increase in the source file size does not affect the perfor-mance of our system. This makes our system highly scalable for distributed self-healing systems.

Foreword ix

Preface xi

1 Introduction 1

Motivation 1

Scenario 1

Economic Considerations 1

Problem Statement 2

Requirements 3

      Self-Healing 4

      Causal Reasoning 7

      Challenges 7

What This Book Is Not 9

References 15

2 CaseStudy: AutonomicHealing-BasedSelf-Management Engine 17

Overview 18

Ubiquitous Networks Industry 21

Autonomic Healing-Based 21

Self-Management Engine (AHSEN) 22

      Software Architecture 24

AHSEN Components 24

      Normal Functionality Model (NFM) 28

      Self-Management Framework (SMF) 28

      Service Lifecycle 30

Simulation Results 40

References 45

3 The Proposed Architecture 47

Introduction 47

Process Conversion to XML Documents 48

Abnormalities Detection 51

      Tag Heterogeneity 51

      Structural Heterogeneity 52

      Assumptions 53

Similarity Matrices 55

      Label Similarity 55

      Pattern Similarity 61

      Vertices Similarity 63

      Tree Edit Distance Similarity 65

4 Policy Engine 67

Introduction 67

Software Architecture 70

      Dynamically Adjustable Policy Engine A Sample Scenario of the Dynamically 70

      Adjustable Rules 71

      Code Generation and Operation in the Policy Engine 76

      Software Architecture of the Policy Engine 78

      Performance of the Policy Engine 81

      Experimental Environment 82

      Performance Comparison 83

      Feature Comparison 84

Novel Rule Methodology 87

References 89

5 Related Work 91

Overview 91

Autonomic Network Management Systems 91

      HYWINMARC 92

      AMUSE 92

      RoSES 93

      AMUN 94

      SMHMS 94

Case-Based Reasoning Systems 95

      CHEMREG 95

      JColibri 95

      IBROW Project 96

      CBR*Tools 96

      NaCoDAW 96

Policy Engine 97

      RETE 97

      Business Rule Markup Language (BRML) 97

      JSR-94 (Java Specification Request) 98

Similarity Approaches 98

      ELIXIR 98

      XIRQL and XXL 98

      Fuzzy Weights 99

      Relaxed Weights 99

      ApproXQL 99

      Query Decomposition Approach 100

Fault Detection 100

      Expert Systems in Fault Detection 100

      Neural Networks in Fault Detection 100

      Qualitative Simulation in On-Line Fault Detection 101

      On-Line Expert Systems in Fault Detection 101

References 102

6 Implementation 113

Overview 113

Implementation Details 114

      Similarity-Based Inverted Index and Pattern Index 114

Create List of Fragments and Regions 116

7 Prototype 121

Parsing of XML Files 121

DOM Object for Each File Created 121

Construct Tree Target 122

Construct Inverted Index 122

Query Processing 122

Construct Pattern Index 122

Fragments Construction Form Pattern Index 124

Demo Screenshots 128

Reference 131

8 Evaluation 133

Performance Graphs 134

      Fault Detection and Traversal 134

Resource Utilization 136

Trends of Causal Reasoning Based Fault Detection 138

References 139

9 Contributions 141

Conceptual Contributions 141

      Causal Reasoning Based Fault Identification 141

      Self-Management Functional Hierarchy 142

      Multifaceted Policy Engine Methodology 144

      Healing Policy Generation 145

Architectures 145

      AHSEN 145

      Policy Engine 146

Software Prototypes 147

References 147

10 Conclusion 151

References 154

Index 155

中科院文献情报中心