KR101288137B1 - Policy based conflict resolution in community computing - Google Patents

Abstract

A method for preventing collision in a community computing system and a community computing development system using the method are disclosed. The community computing development system according to an embodiment of the present invention includes a user interface and a community development unit. The user interface inputs information for implementing the community computing system. The community development department develops a community computing system model using the information and outputs a model script to each computing element so that the developed community computing system model is placed in each computing element. Wherein the information includes a policy for resolving conflicts that may occur in the community computing system. Since the conflict prevention method according to the embodiment of the present invention is solved by using the policy, there is an advantage that the advantages of the community computing system can be maximized by resolving conflicts occurring dynamically in the community computing system.

Description

[0002] Policy-based conflict resolution for community computing [

BRIEF DESCRIPTION OF THE DRAWINGS A brief description of each drawing is provided to more fully understand the drawings recited in the description of the invention.

1 is a diagram for explaining the concept of community computing.

2 is a diagram showing an example of a community model described by CIL-PI.

3 is a diagram showing an example of a policy expressed in the Rei language.

4 is a diagram showing an example of a policy written in the Ponder language.

5 is a diagram illustrating a process of performing community computing.

6 is a block diagram of a community computing system according to an embodiment of the present invention.

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a community computing system, and more particularly, to a method for preventing conflicts using a policy in a community computing system and a community computing development system using the method.

Community computing has been proposed for the development of collaborative systems that interact with smart objects in ubiquitous environments. Community computing is an approach to achieve the goals of the community through the interaction of the computing elements that make up the community, which is a set of computing elements for solving goals in specific situations .

  The computing elements that make up a community can have different roles depending on their own abilities and situations, and can become members of various communities at the request of the community. In dynamic situations where roles and communities change frequently, there is a possibility of conflict between computing elements. In the current community computing model (CCM), there is no consideration of collision at the design stage of the system. Therefore, a community implementation model-platform independent (CIM-PI) Developers who are developing in a specific language need to deal with the computing elements at their discretion when programming their own computing elements.

However, it is not an easy task to program from the beginning considering the factors that may cause conflicts in actual development. Also, there is a problem in that it is reprogrammed and compiled every time a new conflict factor occurs. Therefore, this part should be considered from the design stage, and a solution for this is needed.

Disclosure of Invention Technical Problem [8] The present invention provides a community computing development system that can prevent a conflict using a policy in a community computing system.

It is another object of the present invention to provide a method for preventing a conflict by using a policy in a community computing system.

According to an aspect of the present invention, there is provided a community computing development system including a user interface and a community development unit. The user interface inputs information for implementing the community computing system. The community development department develops a community computing system model using the information and outputs a model script to each computing element so that the developed community computing system model is placed in each computing element. Wherein the information includes a policy for resolving conflicts that may occur in the community computing system.

At this time, the information is preferably described in a CML (Community Computing Modeling Language) format.

Also, the information is preferably described in a CIM-PI (Community Implementation Model-Platform Independent) format.

Meanwhile, the policy is preferably described in the CIM-PI format.

The community development unit includes a model building unit, a community model storing unit, and a model converting unit. The model building unit determines whether the information input from the user interface is a CML form or a CIM-PI form, and generates a community model according to the determined result. The community model storage unit stores the generated community model. The model conversion unit converts the community model stored in the community model storage unit into a script desired by the user and outputs the converted script.

The model construction unit includes a CML construction unit and a PI construction unit. The CML building unit generates a community model suitable for the CML type input information when the information input from the user interface is a CML type. The PI construction unit generates a community model suitable for the CIMM-PI type input information when the information input from the user interface is CIM-PI type.

The model conversion unit may include a CML conversion unit, a PI conversion unit, and a PS conversion unit. The CML conversion unit converts the community model stored in the community model storage unit into a script of the CML type and outputs the converted community model. The PI conversion unit converts the community model stored in the community model storage unit into a CIM-PI type script and outputs the same. The PS conversion unit converts the community model stored in the community model storage unit into a CIM-PS type script and outputs it.

In this case, the PS conversion unit preferably converts the CIM-PI type script converted by the PI conversion unit into a CIM-PS type script.

Also, it is preferable that the PS conversion unit converts the policy described in the CIM-PI format into the CIM-PS format.

According to another aspect of the present invention, there is provided a method for preventing a collision in a community computing system, the method comprising: inputting information for implementing a community computing system; developing a community computing system model using the information; And outputting a model script to each computing element to be placed in each computing element, the information comprising policies for resolving conflicts that may occur in the community computing system.

In order to fully understand the present invention, operational advantages of the present invention, and objects achieved by the practice of the present invention, reference should be made to the accompanying drawings and the accompanying drawings which illustrate preferred embodiments of the present invention.

BEST MODE FOR CARRYING OUT THE INVENTION Hereinafter, the present invention will be described in detail with reference to the preferred embodiments of the present invention with reference to the accompanying drawings. Like reference symbols in the drawings denote like elements.

The ubiquitous environment can be considered as one of complex distributed environments. In addition to the characteristics of general distributed environment, the ubiquitous environment has the characteristics of the ubiquitous environment itself such as dynamic arrangement of service subjects, goal-oriented configuration, and the like. Since existing modeling methods can not consider the characteristics of such ubiquitous environment, they do not fully reflect these characteristics in modeling. Community computing is a modeling technique for developing a collaborative system in a ubiquitous environment, reflecting characteristics of ubiquitous systems compared to existing methods.

Community computing is a proposed method for developing cooperative systems in the ubiquitous environment. Community computing refers to the way in which a ubiquitous environment is regarded as a society and a virtual organization called a community is formed according to the goals that occur within the community to achieve goals through interaction among community members to be. Through community computing, modeling that reflects the characteristics of the ubiquitous environment can be performed, and the relationship between the elements constituting the ubiquitous environment can be explained.

However, current community computing does not take into account any conflicts or exceptions that can occur when the system is running. This can lead to unexpected problems in the execution of the system, and in the implementation phase, the developer should program in consideration of these unexpected situations. If a new situation occurs again, you will have to program and compile the member again. In order to solve these problems, it is necessary to analyze the conflict factors in community computing and discuss how to apply it to the model.

In the present invention, a method for access control in a distributed environment with frequent privilege changes according to a system is proposed, and a method for preventing a conflict occurring in a community computing is proposed. Using this method, it is possible to improve the development efficiency by describing necessary policies according to the situation from the design stage, and making reference to them in the implementation stage.

To this end, the following discussion explains the factors that can arise in the process of constructing and interacting with communities dynamically in order to achieve the goals of the computing elements in the community computing, society, community, and member), and explains examples of policies that are appropriate. Also, the present invention proposes a policy language suitable for community computing by comparing and analyzing existing policy languages for an exemplary policy expression, and proposes a policy converter capable of converting a policy expressed for policy execution.

1. Community computing

Community computing is a proposed method for collaborative system development in ubiquitous environment. FIG. 1 is a diagram for explaining the concept of community computing, and shows a process of modeling an actual domain into a ubiquitous domain. The community computing method considers a specific ubiquitous domain (the ubiquitous domain in FIG. 1) as a society, and a goal generated in the society can be solved through collaboration of computing elements. In community computing, the concept of community is used to achieve dynamically generated goals. A community is a collection of computing entities for achieving goals, dynamically generated as needed, and dynamically destroyed when goals are achieved.

The way to describe a model in community computing is as follows. In the model, we describe the social elements that represent the domains we want to model, and the computing elements that can appear in the domain, namely, social members. As shown in FIG. 1, the community can be described as roles of a community template. In a real ubiquitous area, a community instance corresponds to a community template, and a community instance includes members corresponding to roles of a community template.

After the description of the domain is finished, the following describes problems that may occur within the domain, which can be thought of as a community. The description of the problem describes the goal of the problem, the community members needed to achieve the goal, and the interaction between each member in the community to achieve the goal.

In community computing, two languages are defined for the description of the model: community computing modeling language (CML) and community computing implementation language-platform independent (CIL-PI). Each language differs according to the modeling phase, and a specific model for community computing is described through CIL-PI in the CIM-PI phase. 2 is a diagram showing an example of a community model described by CIL-PI. At this stage, what happens between each community and the roles that make up the community is described in detail.

This modeling technique can reflect computing elements that are dynamically placed in the ubiquitous environment and goal-oriented characteristics. However, as can be seen from the example of FIG. 2, current community computing has no description of the conflict situation or exceptional situation that may occur when the components are executed. In a distributed environment, conflicts occur between interacting elements, and processing of conflicts is essential. In the community computing, the processing of such a conflict is left as a part of the developer, causing a problem that the inside of the computing element must be changed when a new conflict factor occurs. This is an obstacle to efficient system development, so there is a need to solve the problem of collision.

2. Resolving Conflicts in a Distributed Environment

In a distributed environment, when each computing element performs an independent action, a collision occurs between elements. Over the past several years, many studies have been conducted to resolve these conflicts and are divided into several approaches depending on the approach. Negotiation, arbitration, and voting are typical examples. In actual operation, these methods are largely algorithm-based or policy-based.

Algorithm based execution method has a merit that execution speed is fast, but there is a problem that the inside of a computing element must be changed whenever a method for resolving conflict is changed. In addition, the algorithm-based performance method has a disadvantage in that it takes much time to convert each element when the number of computing elements increases and the algorithm changes. Therefore, the algorithm-based performance method is suitable for distributed environments where computing elements are fixed.

On the other hand, the policy-based execution method is advantageous in that it does not need to consider modification of the internal code of the computing element since the policy execution is hardly changed once the execution part of the policy is created and the policy is modified only when the conflict resolution method is changed . Thus, policy-based practices are appropriate for environments where computing elements change dynamically.

Generally, in the community computing based on the ubiquitous environment, computing elements change dynamically and the community dynamically generates and disappears. Therefore, in this community computing, the policy-based performance method is more suitable than the algorithm-based performance method.

2-1. Policy

Policies are defined as information that can be used to change the behavior of the system. In general, policies consist of the necessary authorization and obligation between the subject and the target resource, and a part for resolving conflicts that may occur while performing such a policy. On the other hand, if the policy is distributed through delegation, it is possible to reduce the overhead of centralized policy execution. Therefore, a policy for delegation is additionally required in the distributed environment.

For com- munity computing, it is necessary to discuss meta-policies that can resolve conflicts between duties, delegations, and policies. Privileges are used to control access to resources. In community computing, there is no need to consider policies about privileges because they describe the interactions among members who have their own resources.

2-2. Policy language

A policy language is a language for expressing a policy, and a policy language is essential for expressing a policy. There is no standard language for policy expression yet, but individual studies are under way due to the necessity of policy. Policy languages currently under study include Rei and Ponder. Rei is a policy language for security policy representation in a distributed environment. It supports various delegation policies for distributed environments. However, there is a problem that is not suitable for use in community computing because it focuses on security policy.

3 is a diagram showing an example of a policy expressed in the Rei language. The Rei language defines language based on deontic concepts. This is a basic concept that distinguishes between what a computing element can and can not do for access control. It also helps policy management by defining an ontology for this.

Ponder is a general-purpose policy language that provides a variety of expressive power for use in all domains. The delegation policy provides the most basic expressions of delegation. Since the language is proposed for use in all domains, the language is expressive, but it has a disadvantage in that the size of the language and policy launcher increases for only a specific domain. 4 is a diagram showing an example of a policy written in the Ponder language.

3. Conflicts in Community Computing

3-1. Process of Community Computing

5 is a diagram illustrating a process of performing community computing. In the initialization phase, social administrators and members not belonging to any society are created, members request registration to society (1, 2), and society registers members. After the registration of the members into the society is completed, the members perform their own actions unless a community creation condition occurs.

(4) the community manager creates a community manager for the community (4.1), and (4) requests the community to create a community. . The target community manager casts necessary members to achieve the goals of the community (5, 6) and transmits the necessary protocols to each member's roles (9, 10). In this process, the members provide support for casting (7, 8) and the community manager checks whether the required members are cast (8.1).

After all the protocols have been communicated, each protocol is performed through communication among the community members, starting with the initial action to achieve the goal (11). In this process, each member cast into the community interacts with each other (11.1) and the community's goals are achieved (11.2). When the implementation of the protocol is completed, it means that the goal has been achieved. The member who recognizes the achievement of the goal requests the community manager to annul the community. In this process, the community manager confirms that the goal has been achieved (12) informs the social manager that he has become the target (13), and the social manager annihilates the community in which the goal has been achieved (14).

When the community disappears, it returns to the initial state where the social administrators and members were present. Every time a condition for a stated goal occurs, this process is repeated and the community is created or destroyed dynamically.

However, this community computing model describes the process of community creation and destruction, and there is a lack of description of what should be considered in carrying out the process. In particular, there is a problem in that there is no description about a collision that may occur in the community computing model. Hereinafter, conflict factors that may occur in community computing will be described.

3-2 Conflict Factors in Community Computing

The process of performing the community computing described with reference to FIG. 5 is a success scenario in the case where there is no problem. However, unexpected conflicts can occur in the process of community computing, and the conflicts that may arise in community computing can be divided into conflicts that can occur in society, community, and members depending on the components of community computing. The following is the classification of the conflict factors that can be issued by community computing according to each component.

3-2-1. Collision in Society

Society must manage its members and communities within society. Therefore, major policies at the social level are policies for their management. Society should be able to manage the registration and withdrawal of members, creation and destruction of communities, protocol transmission, and global information in ubiquitous systems. The collision at the level of society is as follows.

 Member's registration conflict: If the member's default behavior is exclusive, the actions of both members may stop or conflict.

 Community Creation Conflicts: When communities A and B are exclusive, the creation of both communities can be requested at the same time. For example, the study community and vacation community for some students are exclusive. In this situation, there is no constraint on community creation, so society creates a community manager for both communities. However, in this case, only one community needs to be created, and processing is required.

 Community Goal Conflicts: If communities are already created that are mutually exclusive, conflicts can arise because the two communities require different goals. For example, if a fire evolving community for A and a community that needs to fire fire for B have been created, they will not be able to meet both A and B requirements. In this case, it is necessary to provide an indicator of what community goals should be implemented first.

3-2-2 Collision in the community

The community manager must manage the protocol between community members and members. Therefore, policy at the community level is mainly concerned with member management and protocol transmission. Here are the community level conflicts:

 Conflicts with members: When a community is created, the community manager will contact members to achieve the community's goals. This process occurs in multiple communities at the same time, and it can happen that two or more communities are trying to engage one member. Members may or may not belong to multiple communities at the same time. Therefore, additional information is required for this. In addition, if you hire a member that you can play a role, the community manager should choose the right member for the community, because it can increase the time to achieve the goal or degrade the overall system performance.

 COMMUNICATIONS BETWEEN MEMBERS: Generally, community managers assume that there are no communication problems between the members, so if a communication problem occurs, the community may stop performing. In many cases, when a communication problem occurs for unexpected reasons, the sending member waits for a response. Therefore, it is necessary to deal with this.

 Conflicts between basic behavior of members: All members perform their actions independently of each other. Thus, the behavior of two or more members can conflict with each other in the course of being performed independently. In the event of a conflict, the actions of the members performing the urgent task must first be ensured. In general, however, this problem can not be solved because the community manager does not prioritize all members.

3-2-3. Collision at member

Members must control their default behavior and the protocol they receive to resolve the conflict. The conflicts that need to be managed at the member level are:

 Outbound Response Collision: A member may receive an outgoing message from multiple community managers. At this time, the member must determine whether he or she can belong to the community. Generally, a member is required to respond immediately when a message is received from the community manager, so that there is a problem that a duplicate community relationship can be created. Depending on the member, it may or may not belong to multiple communities redundantly, so additional information is needed.

 Conflicts between basic behavior and protocols: Community members have their own default behavior and protocols received from the community manager. The basic behavior and the protocol of the member may or may not be performed at the same time. If it can not be performed at the same time, there may be a conflict between the behavior of the member and the protocol, and processing is required for that.

4. Policy language and transformation module for community computing

4-1. Policy language

Existing languages may be used to represent policies used in community computing. Although existing policy languages such as Rei and Ponder have high expressive power of language, they are not suitable for use in portable devices used in ubiquitous environment due to the large size of policy implementors for policy execution. Therefore, there is a need for a new policy language for community computing.

Existing languages include obligation to restrict the behavior of objects, delegation to delegate authority to other objects, meta-policy to manage the relationship between policy and policy, Policy expressions for access control are included. However, in community computing, each member does not need to express access control to resources because he owns the resources he needs.

In the past, it is assumed that, for the purpose of community computing, only the technology related to the meta-policy for limiting the behavior of each computing element according to the situation or against the conflict of policies for behavior restriction is sufficient. Since the computing elements actually have their own resources for their actions, access control on resources is not considered in the current community computing, so it need not be described in the policy. The following paragraphs describe the meaning of simple policy language grammar and grammar for community computing.

The grammar of policy language for community computing is as follows.

<Policy_Description>

:: = <CC_entity> {

<Policy_Body>

}

<CC_entity> :: = <Entity_type> <Identifier>

<Entity_type> :: = <Society> | <Community> | <Member>

<Policy_Body> :: =

{

<Construct>

on <Conflict_Condition>

Action <Action_Body>

}

<Construct> :: = Obligation | Delegation | Meta

<Conflict_Condition>: ==

Member_Registration |

Community_Creation |

Member_Casting |

Member_Communication |

Member_Action |

Casting_Response |

Protocol_Execution

<Action_Body> :: =

{

<Run_Highest_Priority> <Identifier> |

<Run_Shortest_Value> <Identifier> |

<Try_Several_Times> <Identifier> |

<Wait_Limited_Period> <Identifier> |

}

<Identifier> :: = <String>

<String> :: = {<letter> | <digit>} 1+

<letter> :: = <lowercase_letter> | <uppercase_letter>

<lowercase_letter> :: = a | b | c | ... .. | z

<uppercase_letter> :: = A | B | C | ... .. | Z

<digit> :: = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<non_zero_digit> :: = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<positive_integer> :: = <non_zero_digit> <digit> 0+

<negative_integer> :: = - <non_zero_digit> <digit> 0+

<integer> :: = 0 | <positive_integer> | <negative_integer>

4-2. Policy language conversion module

Actually, the policy based execution method is performed using the policy execution module. In the present invention, a policy conversion module is used to check the applicability of the proposed policy language. In the present invention, in order to implement the policy language proposed above, a policy conversion module is inserted into a structure that can be inserted into the existing system development tool (CDTK) Respectively. In the present invention, the community policy is described together with the model at the time of the description of the CIM-PI, and when the conversion process is performed in the CDTK, the community policy is also applied to the community implementation model-platform specific (CIM-PS) Respectively.

4-2-1. Policy Language Conversion Module Overview

In order to reflect the policy into the system, the policy must first be read. In an embodiment of the present invention, the input portion of CDTK is implemented to read up to the policy portion. After that, a community model is created internally based on the loaded model and policy information, and programming codes suitable for the platform are finally generated through codes defined to convert into a language suitable for a specific platform based on the generated model . Since the CDTK used in the prior art is based on the JADE platform, for convenience of description, the embodiment of the present invention generates a Java-based JADE code. However, those skilled in the art will recognize that It will be understood that the invention is not limited thereto.

4-2-2. Conversion module development environment

Table 1 summarizes an example of a policy conversion module development environment to which the present invention may be applied. Agent platforms conforming to the FIPA (Foundation for Intelligent Physical Agent) standard should provide various libraries for multi-agent environments. Since the agent platform used in the embodiment of the present invention is a platform used for confirming the scenario of community computing, the JADE platform is used for the conversion module.

4-2-3. The community computing system &lt; RTI ID = 0.0 &gt;

6 is a block diagram of a community computing system according to an embodiment of the present invention. The community computing system 600 according to an exemplary embodiment of the present invention includes a user interface 610 and a community development unit 620.

Information for implementing the community computing system is input via the user interface 610. [ That is, the user uses the user interface 610 to describe the information about the community computing system to be implemented by the user in the form of CML or CIM-PI. The community development unit 620 develops a community computing system model using information from the user interface 610 and generates a model script 630 so that the developed community computing system model is placed in each computing element. And outputs it to the computing element.

Meanwhile, the community development unit 620 includes a community model storage unit 621, a model building unit 623, and a model conversion unit 625. The model building unit 623 determines whether the information input from the user interface 610 is a CML type or a CIM-PI type, and generates a community model according to the determined result.

More specifically, the model building unit 623 includes a CML building unit 6231 and a PI building unit 6233. [ At this time, if the information input from the user interface 610 is in the CML form, the CML establishing unit 6231 creates a community model suitable for input information in the form of CML. If the information input from the user interface 610 is in the CIM-PI format, the PI construction unit 6233 generates a community model suitable for CIM-PI type input information.

The community model storage unit 621 stores the community model generated by the model building unit 620 and stores the community model generated by the other components (for example, the components included in the model conversion unit 625) If necessary, provide the saved community model to that component.

The model conversion unit 625 converts the community model stored in the community model storage unit 621 into a script of a form desired by the user and outputs the script. For example, if the user wants a community model script of the CML type, the CML conversion unit 6251 converts the community model stored in the community model storage unit 610 into a script of the CML type, and outputs the script to the model script 630 .

Similarly, if the desired community model script is CIM-PI, the PI conversion unit 6253 converts the community model stored in the community model storage unit 610 into a CIM-PI type script, PS format, the PS conversion unit 6255 converts the community model stored in the community model storage unit 610 into a script of the CIM-PS type, (630).

Generally, in the development of a community computing system, since the model script 630 output from the model development unit 620 is dependent on the system, the converted CIM-PS type script is output from the PS conversion unit 6255. However, Those skilled in the art will appreciate that the present invention is not limited thereto.

In general, in the development of the community model system, since the respective types of scripts are sequentially converted into the CML form, the CIM-PI form, and the CIM-PS form, the community model stored in the community model storage unit 621 is a CML form, a CIM- PI type, and CIM-PS type, and output as a CIM-PS type script. However, those skilled in the art will appreciate that the present invention is not limited thereto.

Meanwhile, in the embodiment of the present invention, a policy is described in order to solve a conflict that may occur in a community computing system. The policy described is a CIM-PI form. Therefore, the PI construction unit 623 stores the CIM-PI type policy input from the user interface 610 into the community model storage unit 610.

The policy conversion unit 6257 included in the PS conversion unit 6255 converts the CIM-PI type policy included in the community model into the CIM-PS type and outputs the converted CIM-PI type policy.

In the embodiment of the present invention, since the policy is described in the CIM-PI step, the community model storage unit and the model building unit, which have overall information on the community computing system, process the contents of the policy together. That is, when the community model stored in the community model storage unit is changed from the CIM-PI type to the CIM-PS type, the policies are also converted to fit the platform.

Hereinafter, the configuration and operation of the community computing system according to the embodiment of the present invention will be described in detail using concrete examples. For the sake of explanation, scenarios in which a conflict may occur are created by a method for confirming the usefulness of the policy language and the policy language conversion module proposed by the embodiment of the present invention, a policy for resolving the conflict is envisaged, Lt; / RTI &gt; Also, the actually expressed policy is converted and executed by using the conversion module according to the embodiment of the present invention, thereby verifying the validity of the policy language.

scenario

COEX There is a security robot in a shopping mall like. The robot performs guiding tasks to patrol workers and shoppers. When a woman approaches Robot A and asks for directions, Robot A sends the community manager to the community manager for guidance. At the same time, on the other side, Robot B found a thief and asked to create a community to catch the thief. The social administrator runs a community manager for both communities. The two community managers send out a message to robot A. Robot A, who has decided to do both, responds to both communities. The thief who ran away confronted the guard robot who guided the route, Destroy . The community manager of the roadblocking community where the robot was destroyed will be able to contact the guard robot again, Restart . Also, we have a new robot to catch the thief, keep chasing the thief, let the police know To finish  do.

In a scenario, there may be several conflict situations, and the behavior of the community computing system may not work smoothly if the conflict situation is not handled programmatically. Here is a list of possible crash scenarios:

 Which community should be first created by the firearms administrator when two members request to create a community at the same time?

 How should robot A behave when it receives messages from both communities at the same time?

 What criteria should be used when robot A is to carry out the protocol transmitted from the two communities?

 What should two community managers do when Robot A belonging to the community is broken and communication is not possible?

 How should the community manager behave if there is a problem communicating with members of the community?

In order to solve the above-mentioned conflict situation, various policies can be presented using the policy language proposed in the present invention. The present invention proposes the following policies, but those skilled in the art will recognize that the present invention is not limited by these policies.

<Policy_Description>

{

      Society ShoppingMall

      {

             Obligation on Community_Creation

Action

Run_Highest_Value community.priority

      }

      Community Robbery

      {

              Obligation on Member_Casting

              Action

                      Run_Lowest_Value members.distance

      }

      Member Patrol_Robot

      {

              Obligation on Casting_Response

              Action

                      Wait_Limited_Period responseTime 10

      }

}

The result of generating the JADE-based code using the policy conversion module according to the embodiment of the present invention is as follows.

AID highest;

for (int j = 0; j < members.size - 1; j ++)

{

if (members [j] .priority> members [j] .priority)

highest = members [i] .getAID ();

}

message.sender = highest;

-------------------------------------------------- -----

private class ReplyToCast extends CyclicBehaviour {

    public void action () {

      MessageTemplate mt = MessageTemplate.MatchPerformative (ACLMessage.CFP);

      ACLMessage msg = myAgent.receive (mt);

      if (msg! = null) {

        if (CheckHighest (msg.getContent ()))

             ACLMessage reply = msg.createReply ();

             reply.setPerformative (ACLMessage.PROPOSE);

             reply.setContent ("3");

             myAgent.send (reply);

        }

      }

      else {

        block ();

      }

    }

 case 1:

while (true) {

          reply = myAgent.receive (template);

          if (reply! = null) {

              String cid = reply.getConversationId ();

              if (cid.equalsIgnoreCase (Resource.ACCEPT + Resource.MEMBERCASTING) && findHighestValue (sender.priority)) {

Community.updateMemberList (reply.getSender ());

                            castedMember.put (roleBinding [roleBindingIndex] .getRoleName (), reply.getSender ());

                    System.out.println ("Success casting:" +

                                              reply.getSender ());

                            break;

                        }

                    }

                }

                break;

            }

5-1. Analysis of Conflict Factors in Community Computing

As a result of analyzing the conflict factors that may occur in conventional community computing, conflict factors can be classified according to each computing element for policy distribution and performance. Table 2 summarizes the results of classification.

The conflicts listed in [Table 2] summarize only the conflict factors that can be commonly encountered in community computing.

5-2. Policy language and policy conversion module analysis

In an embodiment of the present invention, the policy language is valuable in that it is a language created to confirm the applicability of the policy. Also, in the embodiment of the present invention, the content of the policy may be expressed in the form of a condition inquiry, for example, 'This computing element should do this when a certain situation occurs.'

Meanwhile, in the embodiment of the present invention, the policy converter converts the contents expressed through the policy language into a form suitable for the JADE platform based on Java. The content of the actually changed code is also in the form of conversion into the form of loop statements and conditional statements.

6-1 Policy Based Community Computing Analysis

[Table 3] compares policy-based community computing with existing community computing.

Compared with existing community computing, policy-based community computing not only describes situations that are not taken into consideration, but also automatically generates code for the policy, thereby reducing user's efforts in terms of productivity and maintenance of the system .

As described above, an optimal embodiment has been disclosed in the drawings and specification. Although specific terms have been employed herein, they are used for purposes of illustration only and are not intended to limit the scope of the invention as defined in the claims or the claims. Therefore, those skilled in the art will appreciate that various modifications and equivalent embodiments are possible without departing from the scope of the present invention. Accordingly, the true scope of the present invention should be determined by the technical idea of the appended claims.

As described above, since the conflict prevention method according to the embodiment of the present invention is solved by using the policy, there is an advantage that the advantages of the community computing system can be maximized by resolving conflicts occurring dynamically in the community computing system.

In addition, the collision avoidance method according to an embodiment of the present invention not only can describe a situation that is not considered in conventional community computing but also automatically generates a code for a policy, thereby improving productivity and maintenance There is an advantage that the user's efforts can be reduced.

Claims (17)

A user interface for entering information for implementing a community computing system; And A community development unit that develops a community computing system model using the information and outputs a model script to each computing element so that the developed community computing system model is placed in each computing element, The information includes a policy for resolving conflicts that may occur in the community computing system and is described in a form of a community computing modeling language (CML) or a community implement model-platform independent (CIM-PI) The community development department, A model building unit for determining whether the information input from the user interface is a CML form or a CIM-PI form and generating a community model according to the determined result; A community model storage unit for storing the generated community model; And And a model conversion unit for converting the community model stored in the community model storage unit into a script of a desired form and outputting the converted script. delete delete The method according to claim 1, Wherein the policy is described in a CIM-PI format. delete 2. The image processing apparatus according to claim 1, A CML building unit for generating a community model suitable for the input information of the CML type when the information input from the user interface is a CML form; And And a PI construction unit for generating a community model suitable for the CIMM-PI type input information when the information input from the user interface is a CIM-PI form. 2. The image processing apparatus according to claim 1, A CML conversion unit for converting the community model stored in the community model storage unit into a CML type script and outputting the script; A PI conversion unit converting the community model stored in the community model storage unit into a CIM-PI type script and outputting the script; And And a PS converting unit converting the community model stored in the community model storing unit into a CIM-PS type script and outputting the converted result. 8. The method of claim 7, Wherein the PS conversion unit converts the CIM-PI type script converted by the PI conversion unit into a CIM-PS type script. 8. The apparatus of claim 7, And converting the policy described in the CIM-PI format into the CIM-PS format. Receiving a user interface for inputting information for implementing a community computing system; And And outputting a model script to each computing element so that the community development department develops a community computing system model using the information and a developed community computing system model is placed in each computing element, The information includes a policy for resolving conflicts that may occur in the community computing system and is described in a form of a community computing modeling language (CML) or a community implement model-platform independent (CIM-PI) Wherein the outputting step comprises: Determining whether the information input from the user interface is CML type or CIM-PI type, and generating a community model according to the determined result; The community model storage unit storing the generated community model; And And converting the community model stored in the community model storage unit into a script desired by the user and outputting the converted community model. delete delete 11. The method of claim 10, Wherein the policy is described in a CIM-PI format. delete 11. The method of claim 10, A CML model generation step of generating a community model suitable for the CML type input information when the CML building unit inputs the information input from the user interface as a CML type; And And a PI model generation step of generating a community model suitable for the input information of the CIMM-PI type when the PI construction unit inputs the information input from the user interface in the form of CIM-PI. 11. The method of claim 10, wherein the converting and outputting comprises: Converting the community model stored in the community model storage unit into a CML type script and outputting the converted community model; Converting the community model stored in the community model storage unit into a CIM-PI type script and outputting the script; And PS conversion unit converts the community model stored in the community model storage unit into a CIM-PS type script, and outputs the converted community model. 17. The method of claim 16, wherein the step of converting the PS conversion unit into a CIM- And converting the policy described in the CIM-PI format into the CIM-PS format.

Images