Mechanism to build dynamic locations to reduce brittleness in a team environment
View Patent ↗Mechanisms to build dynamic locations to reduce brittleness in a team environment are provided. A project includes resources, each resource is assigned a key. Each key is mapped to a current location for its corresponding resource. The keys and locations are maintained in an index. Locations for the resources can change as desired throughout the lifecycle of the project and as changes occur the index is updated. When references are made within the project to the resources, the references are translated to the keys, if necessary. The keys are then used for accessing the index and dynamically acquiring the current locations for the resources at the time the references are made.
1. A machine-implemented method, comprising:
identifying a reference made to a first resource that originates from an application processing on a machine;
determining that the reference is a first key associated with the first resource;
resolving the first key to a current location known for the first resource by using the key to access a map that points to the current location, a dynamic mapping to the current location is maintained permitting a legacy location for the application to change to the current location without breaking other applications that depend on the first resource; and
redirecting the reference that originated from the application and directed to the legacy location to the current location for the application to access the first resource.
2. The machine-implemented method of claim 1 further comprising:
detecting a load of a project having the first resource and other resources within a processing environment associated with the machine or an entirely different machine of a network; and
scanning the project during the load for the current location of the first resource and maintaining an index having the first key that maps to the current location.
3. The machine-implemented method of claim 2 , wherein scanning further includes detecting the first key as being referenced during the load as an identifier for the first resource.
4. The machine-implemented method of claim 2 , wherein scanning further includes generating the first key as a globally unique identifier (GUID) during a first load of the project.
5. The machine-implemented method of claim 1 , wherein identifying further includes monitoring calls that emanate from the application to detect the reference.
6. The machine-implemented method of claim 1 , wherein resolving further includes identifying the first resource as a file that is located at the current location and is at least partially named within the current location using the first key.
7. A machine-implemented method, comprising:
detecting an initial first load of a project that includes multiple resources;
scanning the project to identify the resources within the project;
generating a key for each resource, renaming each file that defines each resource within its current location of the project to include as part of each file's name the corresponding key assigned to that resource;
recording a current location for each resource;
producing an index that maps each key to its corresponding current location, and maintaining a dynamic mapping to the current location permitting a legacy location that references each resource to change without breaking other applications that depend on each of the resources; and
subsequently resolving references made to each of the resources, each reference directed to a particular resource's legacy location, by using the index with particular keys for each of the references to obtain and to return particular current locations for each of the resources that are associated with the particular keys.
8. The machine-implemented method of claim 7 further comprising:
rescanning the project on each subsequent load that follows the initial load; and
updating the index with new current locations for some of the resources that were moved since the initial load within the project.
9. The machine-implemented method of claim 8 , wherein rescanning further includes identifying some project embedded references on each subsequent load that identify some of the resources, wherein the project embedded references include the corresponding keys for those resources that were generated during the initial load; and using those corresponding keys to update the index with the new current locations for those resources.
10. The machine-implemented method of claim 8 , wherein rescanning further includes identifying some project embedded references on each subsequent load that identify some of the resources, wherein the project embedded references include old file paths for those resources that were used during the initial load of the project; and hashing the old file paths to the corresponding keys for those resources and then using those corresponding keys to update the index with the new current locations for those resources.
11. The machine-implemented method of claim 7 , wherein generating further includes using factors to generate each key via a hashing algorithm that takes as input the factors and produces each key, the factors include one or more of the following: an identity for a particular resource, a full directory path location representing a particular current location for the particular resource, a project identity for the project, a file name for the particular resource, and a processing environment identity for a processing environment of the project.
12. The machine-implemented method of claim 7 , wherein subsequently resolving further includes dynamically detecting the references being made by applications processing within the project, and wherein each detected reference is identified as a key reference to one of the keys or a file path reference that is dynamically hashed to the key reference.
13. A machine-implemented system, comprising:
a machine having a key generator implemented in a non-transitory computer-readable storage medium and to process on the machine within a network; and
the machine of a different machine having a key manager implemented in a non-transitory computer-readable storage medium and to process on the machine or the different machine of the network;
wherein the key generator is to generate a key for a resource of a project when the project is loaded within a project processing environment for a first time, and wherein the key manager uses the key to create an index that maps the key to an initial location for the resource within the project, and the key is inserted back into the project for specific references made to the resource within the project, and wherein the initial location subsequently changes during subsequent loads of the project within the project processing environment and the key manager updates the index to map the key to the changed location, and wherein the key manager dynamically resolves references made to the resource, the references directed to the initial location for the resource, during a lifecycle of the project to a then-current location for the resource within the project processing environment using the key embedded with those references in the project, dynamic mappings are maintained to the then-current location permitting the initial location for the resource to dynamically change without breaking other applications that depend on the resource.
14. The machine-implemented system of claim 13 , wherein the key generator uses a variety of pre-configured factors associated with the resource in combination with a hashing algorithm to generate the key.
15. The machine-implemented system of claim 13 , wherein the key manager is to rename a file that defines the resource so that at least a portion of a name for the file includes the key.
16. The machine-implemented system of claim 13 , wherein the key manager permits the references made to the resource to include the key or previously valid file paths to the resource that are no longer accurate to access the resource.
17. The machine-implemented system of claim 13 , wherein the key manager dynamically detects when a current location for the resource changes while the project is being processed and dynamically updates the index to reflect that change, and wherein the update to the index occurs in between loads of the project.
18. A machine-implemented system, comprising:
one or more machines of a network having a project represented as resources that are implemented in a non-transitory computer-readable storage medium and that processes on the one or more machines of the network; and
the one or more machines of the network having a resource resolver service implemented in a non-transitory computer-readable storage medium and that processes on the one of the machines of the network;
wherein when the project is initially loaded into a project processing environment on the machines, embedded references to the resources within the project are translated to keys, and the keys are inserted into the project with the embedded references, each key for each resource maps to a then-existing location for that resource within the project processing environment, and wherein the resource resolver service dynamically resolves references made for the resources, the references directed to legacy locations for the resources, by using the keys and locating the then-existing location for each of the resources within the project processing environment that are associated with those keys, dynamic mappings are maintained to each resource's the then-existing location permitting the legacy location of each resource to change without breaking other applications that depend on each of the resources.
19. The machine-implemented system of claim 18 , wherein the resource resolving service intercepts the processing references during execution of the project and supplies the current locations.
20. The machine-implemented system of claim 18 , wherein the keys and the then-existing locations for the resources are maintained in an index that is dynamically updated to reflect the current locations, and wherein the keys remain unchanged within the index.
21. The machine-implemented system of claim 20 , wherein the processing references are hashed by the resource resolving service to acquire the keys that are then used to search the index for the current locations.
22. The machine-implemented system of claim 18 , wherein the keys are randomly generated and each key is used as part of a file name that defines a corresponding resource to which that key relates.