github.com/hernad/nomad@v1.6.112/nomad/mock/alloc.go (about)

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package mock
     5  
     6  import (
     7  	"math/rand"
     8  
     9  	"github.com/hernad/nomad/helper/uuid"
    10  	"github.com/hernad/nomad/nomad/structs"
    11  )
    12  
    13  func Alloc() *structs.Allocation {
    14  	job := Job()
    15  	alloc := &structs.Allocation{
    16  		ID:        uuid.Generate(),
    17  		EvalID:    uuid.Generate(),
    18  		NodeID:    "12345678-abcd-efab-cdef-123456789abc",
    19  		Namespace: structs.DefaultNamespace,
    20  		TaskGroup: "web",
    21  
    22  		// TODO Remove once clientv2 gets merged
    23  		Resources: &structs.Resources{
    24  			CPU:      500,
    25  			MemoryMB: 256,
    26  			DiskMB:   150,
    27  			Networks: []*structs.NetworkResource{
    28  				{
    29  					Device:        "eth0",
    30  					IP:            "192.168.0.100",
    31  					ReservedPorts: []structs.Port{{Label: "admin", Value: 5000}},
    32  					MBits:         50,
    33  					DynamicPorts:  []structs.Port{{Label: "http"}},
    34  				},
    35  			},
    36  		},
    37  		TaskResources: map[string]*structs.Resources{
    38  			"web": {
    39  				CPU:      500,
    40  				MemoryMB: 256,
    41  				Networks: []*structs.NetworkResource{
    42  					{
    43  						Device:        "eth0",
    44  						IP:            "192.168.0.100",
    45  						ReservedPorts: []structs.Port{{Label: "admin", Value: 5000}},
    46  						MBits:         50,
    47  						DynamicPorts:  []structs.Port{{Label: "http", Value: 9876}},
    48  					},
    49  				},
    50  			},
    51  		},
    52  		SharedResources: &structs.Resources{
    53  			DiskMB: 150,
    54  		},
    55  
    56  		AllocatedResources: &structs.AllocatedResources{
    57  			Tasks: map[string]*structs.AllocatedTaskResources{
    58  				"web": {
    59  					Cpu: structs.AllocatedCpuResources{
    60  						CpuShares: 500,
    61  					},
    62  					Memory: structs.AllocatedMemoryResources{
    63  						MemoryMB: 256,
    64  					},
    65  					Networks: []*structs.NetworkResource{
    66  						{
    67  							Device:        "eth0",
    68  							IP:            "192.168.0.100",
    69  							ReservedPorts: []structs.Port{{Label: "admin", Value: 5000}},
    70  							MBits:         50,
    71  							DynamicPorts:  []structs.Port{{Label: "http", Value: 9876}},
    72  						},
    73  					},
    74  				},
    75  			},
    76  			Shared: structs.AllocatedSharedResources{
    77  				DiskMB: 150,
    78  			},
    79  		},
    80  		Job:           job,
    81  		DesiredStatus: structs.AllocDesiredStatusRun,
    82  		ClientStatus:  structs.AllocClientStatusPending,
    83  	}
    84  	alloc.JobID = alloc.Job.ID
    85  	alloc.Canonicalize()
    86  	return alloc
    87  }
    88  
    89  func MinAlloc() *structs.Allocation {
    90  	job := MinJob()
    91  	group := job.TaskGroups[0]
    92  	task := group.Tasks[0]
    93  	return &structs.Allocation{
    94  		ID:            uuid.Generate(),
    95  		EvalID:        uuid.Generate(),
    96  		NodeID:        uuid.Generate(),
    97  		Job:           job,
    98  		TaskGroup:     group.Name,
    99  		ClientStatus:  structs.AllocClientStatusPending,
   100  		DesiredStatus: structs.AllocDesiredStatusRun,
   101  		AllocatedResources: &structs.AllocatedResources{
   102  			Tasks: map[string]*structs.AllocatedTaskResources{
   103  				task.Name: {
   104  					Cpu: structs.AllocatedCpuResources{
   105  						CpuShares: 100,
   106  					},
   107  					Memory: structs.AllocatedMemoryResources{
   108  						MemoryMB: 256,
   109  					},
   110  				},
   111  			},
   112  			Shared: structs.AllocatedSharedResources{
   113  				DiskMB: 150,
   114  			},
   115  		},
   116  	}
   117  }
   118  
   119  func AllocWithoutReservedPort() *structs.Allocation {
   120  	alloc := Alloc()
   121  	alloc.Resources.Networks[0].ReservedPorts = nil
   122  	alloc.TaskResources["web"].Networks[0].ReservedPorts = nil
   123  	alloc.AllocatedResources.Tasks["web"].Networks[0].ReservedPorts = nil
   124  
   125  	return alloc
   126  }
   127  
   128  func AllocForNode(n *structs.Node) *structs.Allocation {
   129  	nodeIP := n.NodeResources.NodeNetworks[0].Addresses[0].Address
   130  
   131  	dynamicPortRange := structs.DefaultMaxDynamicPort - structs.DefaultMinDynamicPort
   132  	randomDynamicPort := rand.Intn(dynamicPortRange) + structs.DefaultMinDynamicPort
   133  
   134  	alloc := Alloc()
   135  	alloc.NodeID = n.ID
   136  
   137  	// Set node IP address.
   138  	alloc.Resources.Networks[0].IP = nodeIP
   139  	alloc.TaskResources["web"].Networks[0].IP = nodeIP
   140  	alloc.AllocatedResources.Tasks["web"].Networks[0].IP = nodeIP
   141  
   142  	// Set dynamic port to a random value.
   143  	alloc.TaskResources["web"].Networks[0].DynamicPorts = []structs.Port{{Label: "http", Value: randomDynamicPort}}
   144  	alloc.AllocatedResources.Tasks["web"].Networks[0].DynamicPorts = []structs.Port{{Label: "http", Value: randomDynamicPort}}
   145  
   146  	return alloc
   147  
   148  }
   149  
   150  func AllocForNodeWithoutReservedPort(n *structs.Node) *structs.Allocation {
   151  	nodeIP := n.NodeResources.NodeNetworks[0].Addresses[0].Address
   152  
   153  	dynamicPortRange := structs.DefaultMaxDynamicPort - structs.DefaultMinDynamicPort
   154  	randomDynamicPort := rand.Intn(dynamicPortRange) + structs.DefaultMinDynamicPort
   155  
   156  	alloc := AllocWithoutReservedPort()
   157  	alloc.NodeID = n.ID
   158  
   159  	// Set node IP address.
   160  	alloc.Resources.Networks[0].IP = nodeIP
   161  	alloc.TaskResources["web"].Networks[0].IP = nodeIP
   162  	alloc.AllocatedResources.Tasks["web"].Networks[0].IP = nodeIP
   163  
   164  	// Set dynamic port to a random value.
   165  	alloc.TaskResources["web"].Networks[0].DynamicPorts = []structs.Port{{Label: "http", Value: randomDynamicPort}}
   166  	alloc.AllocatedResources.Tasks["web"].Networks[0].DynamicPorts = []structs.Port{{Label: "http", Value: randomDynamicPort}}
   167  
   168  	return alloc
   169  }
   170  
   171  func SysBatchAlloc() *structs.Allocation {
   172  	job := SystemBatchJob()
   173  	return &structs.Allocation{
   174  		ID:        uuid.Generate(),
   175  		EvalID:    uuid.Generate(),
   176  		NodeID:    "12345678-abcd-efab-cdef-123456789abc",
   177  		Namespace: structs.DefaultNamespace,
   178  		TaskGroup: "pinger",
   179  		AllocatedResources: &structs.AllocatedResources{
   180  			Tasks: map[string]*structs.AllocatedTaskResources{
   181  				"ping-example": {
   182  					Cpu:    structs.AllocatedCpuResources{CpuShares: 500},
   183  					Memory: structs.AllocatedMemoryResources{MemoryMB: 256},
   184  					Networks: []*structs.NetworkResource{{
   185  						Device: "eth0",
   186  						IP:     "192.168.0.100",
   187  					}},
   188  				},
   189  			},
   190  			Shared: structs.AllocatedSharedResources{DiskMB: 150},
   191  		},
   192  		Job:           job,
   193  		JobID:         job.ID,
   194  		DesiredStatus: structs.AllocDesiredStatusRun,
   195  		ClientStatus:  structs.AllocClientStatusPending,
   196  	}
   197  }
   198  
   199  func SystemAlloc() *structs.Allocation {
   200  	alloc := &structs.Allocation{
   201  		ID:        uuid.Generate(),
   202  		EvalID:    uuid.Generate(),
   203  		NodeID:    "12345678-abcd-efab-cdef-123456789abc",
   204  		Namespace: structs.DefaultNamespace,
   205  		TaskGroup: "web",
   206  
   207  		// TODO Remove once clientv2 gets merged
   208  		Resources: &structs.Resources{
   209  			CPU:      500,
   210  			MemoryMB: 256,
   211  			DiskMB:   150,
   212  			Networks: []*structs.NetworkResource{
   213  				{
   214  					Device:        "eth0",
   215  					IP:            "192.168.0.100",
   216  					ReservedPorts: []structs.Port{{Label: "admin", Value: 5000}},
   217  					MBits:         50,
   218  					DynamicPorts:  []structs.Port{{Label: "http"}},
   219  				},
   220  			},
   221  		},
   222  		TaskResources: map[string]*structs.Resources{
   223  			"web": {
   224  				CPU:      500,
   225  				MemoryMB: 256,
   226  				Networks: []*structs.NetworkResource{
   227  					{
   228  						Device:        "eth0",
   229  						IP:            "192.168.0.100",
   230  						ReservedPorts: []structs.Port{{Label: "admin", Value: 5000}},
   231  						MBits:         50,
   232  						DynamicPorts:  []structs.Port{{Label: "http", Value: 9876}},
   233  					},
   234  				},
   235  			},
   236  		},
   237  		SharedResources: &structs.Resources{
   238  			DiskMB: 150,
   239  		},
   240  
   241  		AllocatedResources: &structs.AllocatedResources{
   242  			Tasks: map[string]*structs.AllocatedTaskResources{
   243  				"web": {
   244  					Cpu: structs.AllocatedCpuResources{
   245  						CpuShares: 500,
   246  					},
   247  					Memory: structs.AllocatedMemoryResources{
   248  						MemoryMB: 256,
   249  					},
   250  					Networks: []*structs.NetworkResource{
   251  						{
   252  							Device:        "eth0",
   253  							IP:            "192.168.0.100",
   254  							ReservedPorts: []structs.Port{{Label: "admin", Value: 5000}},
   255  							MBits:         50,
   256  							DynamicPorts:  []structs.Port{{Label: "http", Value: 9876}},
   257  						},
   258  					},
   259  				},
   260  			},
   261  			Shared: structs.AllocatedSharedResources{
   262  				DiskMB: 150,
   263  			},
   264  		},
   265  		Job:           SystemJob(),
   266  		DesiredStatus: structs.AllocDesiredStatusRun,
   267  		ClientStatus:  structs.AllocClientStatusPending,
   268  	}
   269  	alloc.JobID = alloc.Job.ID
   270  	return alloc
   271  }