How to use Forward method of vm Package

Best Syzkaller code snippet using vm.Forward

resource_cloudstack_port_forward.go

Source:resource_cloudstack_port_forward.go

...9	"github.com/hashicorp/go-multierror"10	"github.com/hashicorp/terraform/helper/schema"11	"github.com/xanzy/go-cloudstack/cloudstack"12)13func resourceCloudStackPortForward() *schema.Resource {14	return &schema.Resource{15		Create: resourceCloudStackPortForwardCreate,16		Read:   resourceCloudStackPortForwardRead,17		Update: resourceCloudStackPortForwardUpdate,18		Delete: resourceCloudStackPortForwardDelete,19		Schema: map[string]*schema.Schema{20			"ip_address_id": &schema.Schema{21				Type:     schema.TypeString,22				Required: true,23				ForceNew: true,24			},25			"managed": &schema.Schema{26				Type:     schema.TypeBool,27				Optional: true,28				Default:  false,29			},30			"project": &schema.Schema{31				Type:     schema.TypeString,32				Optional: true,33				ForceNew: true,34			},35			"forward": &schema.Schema{36				Type:     schema.TypeSet,37				Required: true,38				Elem: &schema.Resource{39					Schema: map[string]*schema.Schema{40						"protocol": &schema.Schema{41							Type:     schema.TypeString,42							Required: true,43						},44						"private_port": &schema.Schema{45							Type:     schema.TypeInt,46							Required: true,47						},48						"public_port": &schema.Schema{49							Type:     schema.TypeInt,50							Required: true,51						},52						"virtual_machine_id": &schema.Schema{53							Type:     schema.TypeString,54							Required: true,55						},56						"vm_guest_ip": &schema.Schema{57							Type:     schema.TypeString,58							Optional: true,59						},60						"uuid": &schema.Schema{61							Type:     schema.TypeString,62							Computed: true,63						},64					},65				},66			},67		},68	}69}70func resourceCloudStackPortForwardCreate(d *schema.ResourceData, meta interface{}) error {71	// We need to set this upfront in order to be able to save a partial state72	d.SetId(d.Get("ip_address_id").(string))73	// Create all forwards that are configured74	if nrs := d.Get("forward").(*schema.Set); nrs.Len() > 0 {75		// Create an empty schema.Set to hold all forwards76		forwards := resourceCloudStackPortForward().Schema["forward"].ZeroValue().(*schema.Set)77		err := createPortForwards(d, meta, forwards, nrs)78		// We need to update this first to preserve the correct state79		d.Set("forward", forwards)80		if err != nil {81			return err82		}83	}84	return resourceCloudStackPortForwardRead(d, meta)85}86func createPortForwards(d *schema.ResourceData, meta interface{}, forwards *schema.Set, nrs *schema.Set) error {87	var errs *multierror.Error88	var wg sync.WaitGroup89	wg.Add(nrs.Len())90	sem := make(chan struct{}, 10)91	for _, forward := range nrs.List() {92		// Put in a tiny sleep here to avoid DoS'ing the API93		time.Sleep(500 * time.Millisecond)94		go func(forward map[string]interface{}) {95			defer wg.Done()96			sem <- struct{}{}97			// Create a single forward98			err := createPortForward(d, meta, forward)99			// If we have a UUID, we need to save the forward100			if forward["uuid"].(string) != "" {101				forwards.Add(forward)102			}103			if err != nil {104				errs = multierror.Append(errs, err)105			}106			<-sem107		}(forward.(map[string]interface{}))108	}109	wg.Wait()110	return errs.ErrorOrNil()111}112func createPortForward(d *schema.ResourceData, meta interface{}, forward map[string]interface{}) error {113	cs := meta.(*cloudstack.CloudStackClient)114	// Make sure all required parameters are there115	if err := verifyPortForwardParams(d, forward); err != nil {116		return err117	}118	vm, _, err := cs.VirtualMachine.GetVirtualMachineByID(119		forward["virtual_machine_id"].(string),120		cloudstack.WithProject(d.Get("project").(string)),121	)122	if err != nil {123		return err124	}125	// Create a new parameter struct126	p := cs.Firewall.NewCreatePortForwardingRuleParams(d.Id(), forward["private_port"].(int),127		forward["protocol"].(string), forward["public_port"].(int), vm.Id)128	if vmGuestIP, ok := forward["vm_guest_ip"]; ok && vmGuestIP.(string) != "" {129		p.SetVmguestip(vmGuestIP.(string))130		// Set the network ID based on the guest IP, needed when the public IP address131		// is not associated with any network yet132	NICS:133		for _, nic := range vm.Nic {134			if vmGuestIP.(string) == nic.Ipaddress {135				p.SetNetworkid(nic.Networkid)136				break NICS137			}138			for _, ip := range nic.Secondaryip {139				if vmGuestIP.(string) == ip.Ipaddress {140					p.SetNetworkid(nic.Networkid)141					break NICS142				}143			}144		}145	} else {146		// If no guest IP is configured, use the primary NIC147		p.SetNetworkid(vm.Nic[0].Networkid)148	}149	// Do not open the firewall automatically in any case150	p.SetOpenfirewall(false)151	r, err := cs.Firewall.CreatePortForwardingRule(p)152	if err != nil {153		return err154	}155	forward["uuid"] = r.Id156	return nil157}158func resourceCloudStackPortForwardRead(d *schema.ResourceData, meta interface{}) error {159	cs := meta.(*cloudstack.CloudStackClient)160	// First check if the IP address is still associated161	_, count, err := cs.Address.GetPublicIpAddressByID(162		d.Id(),163		cloudstack.WithProject(d.Get("project").(string)),164	)165	if err != nil {166		if count == 0 {167			log.Printf(168				"[DEBUG] IP address with ID %s is no longer associated", d.Id())169			d.SetId("")170			return nil171		}172		return err173	}174	// Get all the forwards from the running environment175	p := cs.Firewall.NewListPortForwardingRulesParams()176	p.SetIpaddressid(d.Id())177	p.SetListall(true)178	if err := setProjectid(p, cs, d); err != nil {179		return err180	}181	l, err := cs.Firewall.ListPortForwardingRules(p)182	if err != nil {183		return err184	}185	// Make a map of all the forwards so we can easily find a forward186	forwardMap := make(map[string]*cloudstack.PortForwardingRule, l.Count)187	for _, f := range l.PortForwardingRules {188		forwardMap[f.Id] = f189	}190	// Create an empty schema.Set to hold all forwards191	forwards := resourceCloudStackPortForward().Schema["forward"].ZeroValue().(*schema.Set)192	// Read all forwards that are configured193	if rs := d.Get("forward").(*schema.Set); rs.Len() > 0 {194		for _, forward := range rs.List() {195			forward := forward.(map[string]interface{})196			id, ok := forward["uuid"]197			if !ok || id.(string) == "" {198				continue199			}200			// Get the forward201			f, ok := forwardMap[id.(string)]202			if !ok {203				forward["uuid"] = ""204				continue205			}206			// Delete the known rule so only unknown rules remain in the ruleMap207			delete(forwardMap, id.(string))208			privPort, err := strconv.Atoi(f.Privateport)209			if err != nil {210				return err211			}212			pubPort, err := strconv.Atoi(f.Publicport)213			if err != nil {214				return err215			}216			// Update the values217			forward["protocol"] = f.Protocol218			forward["private_port"] = privPort219			forward["public_port"] = pubPort220			forward["virtual_machine_id"] = f.Virtualmachineid221			// This one is a bit tricky. We only want to update this optional value222			// if we've set one ourselves. If not this would become a computed value223			// and that would mess up the calculated hash of the set item.224			if forward["vm_guest_ip"].(string) != "" {225				forward["vm_guest_ip"] = f.Vmguestip226			}227			forwards.Add(forward)228		}229	}230	// If this is a managed resource, add all unknown forwards to dummy forwards231	managed := d.Get("managed").(bool)232	if managed && len(forwardMap) > 0 {233		for uuid := range forwardMap {234			// Make a dummy forward to hold the unknown UUID235			forward := map[string]interface{}{236				"protocol":           uuid,237				"private_port":       0,238				"public_port":        0,239				"virtual_machine_id": uuid,240				"uuid":               uuid,241			}242			// Add the dummy forward to the forwards set243			forwards.Add(forward)244		}245	}246	if forwards.Len() > 0 {247		d.Set("forward", forwards)248	} else if !managed {249		d.SetId("")250	}251	return nil252}253func resourceCloudStackPortForwardUpdate(d *schema.ResourceData, meta interface{}) error {254	// Check if the forward set as a whole has changed255	if d.HasChange("forward") {256		o, n := d.GetChange("forward")257		ors := o.(*schema.Set).Difference(n.(*schema.Set))258		nrs := n.(*schema.Set).Difference(o.(*schema.Set))259		// We need to start with a rule set containing all the rules we260		// already have and want to keep. Any rules that are not deleted261		// correctly and any newly created rules, will be added to this262		// set to make sure we end up in a consistent state263		forwards := o.(*schema.Set).Intersection(n.(*schema.Set))264		// First loop through all the old forwards and delete them265		if ors.Len() > 0 {266			err := deletePortForwards(d, meta, forwards, ors)267			// We need to update this first to preserve the correct state268			d.Set("forward", forwards)269			if err != nil {270				return err271			}272		}273		// Then loop through all the new forwards and create them274		if nrs.Len() > 0 {275			err := createPortForwards(d, meta, forwards, nrs)276			// We need to update this first to preserve the correct state277			d.Set("forward", forwards)278			if err != nil {279				return err280			}281		}282	}283	return resourceCloudStackPortForwardRead(d, meta)284}285func resourceCloudStackPortForwardDelete(d *schema.ResourceData, meta interface{}) error {286	// Create an empty rule set to hold all rules that where287	// not deleted correctly288	forwards := resourceCloudStackPortForward().Schema["forward"].ZeroValue().(*schema.Set)289	// Delete all forwards290	if ors := d.Get("forward").(*schema.Set); ors.Len() > 0 {291		err := deletePortForwards(d, meta, forwards, ors)292		// We need to update this first to preserve the correct state293		d.Set("forward", forwards)294		if err != nil {295			return err296		}297	}298	return nil299}300func deletePortForwards(d *schema.ResourceData, meta interface{}, forwards *schema.Set, ors *schema.Set) error {301	var errs *multierror.Error302	var wg sync.WaitGroup303	wg.Add(ors.Len())304	sem := make(chan struct{}, 10)305	for _, forward := range ors.List() {306		// Put a sleep here to avoid DoS'ing the API307		time.Sleep(500 * time.Millisecond)308		go func(forward map[string]interface{}) {309			defer wg.Done()310			sem <- struct{}{}311			// Delete a single forward312			err := deletePortForward(d, meta, forward)313			// If we have a UUID, we need to save the forward314			if forward["uuid"].(string) != "" {315				forwards.Add(forward)316			}317			if err != nil {318				errs = multierror.Append(errs, err)319			}320			<-sem321		}(forward.(map[string]interface{}))322	}323	wg.Wait()324	return errs.ErrorOrNil()325}326func deletePortForward(d *schema.ResourceData, meta interface{}, forward map[string]interface{}) error {327	cs := meta.(*cloudstack.CloudStackClient)328	// Create the parameter struct329	p := cs.Firewall.NewDeletePortForwardingRuleParams(forward["uuid"].(string))330	// Delete the forward331	if _, err := cs.Firewall.DeletePortForwardingRule(p); err != nil {332		// This is a very poor way to be told the ID does no longer exist :(333		if !strings.Contains(err.Error(), fmt.Sprintf(334			"Invalid parameter id value=%s due to incorrect long value format, "+335				"or entity does not exist", forward["uuid"].(string))) {336			return err337		}338	}339	// Empty the UUID of this rule340	forward["uuid"] = ""341	return nil342}343func verifyPortForwardParams(d *schema.ResourceData, forward map[string]interface{}) error {344	protocol := forward["protocol"].(string)345	if protocol != "tcp" && protocol != "udp" {346		return fmt.Errorf(347			"%s is not a valid protocol. Valid options are 'tcp' and 'udp'", protocol)348	}349	return nil350}...

port.go

Source:port.go

...21)22// portCmd represents the port command23var portCmd = &cobra.Command{24	Use:   "port",25	Short: "Forward port(s) from a VM to host",26	Long: `Forward port(s) from a VM to host27Usage: vermin port <vm> [local port:]<vm port> [[local port:]<vm port>...]28Where local port and vm port can take a form of range like: 9090-9095 or a single port like 909029`,30	Example: `31Forward vm port 4040 to local port 4040:32$ vermin port vm_01 404033Forward vm port 4040 to local port 40040:34$ vermin port vm_01 40040:404035Forward vm port 4040 to local port 40040 and port 8080 to 808036$ vermin port vm_01 40040:4040 808037Forward vm port 4040 to local port 40040 and ports in range (8080 to 8088) to range(8080 to 8088):38$ vermin port vm_01 40040:4040 8080-808839Forward vm port 4040 to local port 40040 and ports in range (8080 to 8088) to range(9080 to 9088):40$ vermin port vm_01 40040:4040 9080-9088:8080-808841`,42	Run: func(cmd *cobra.Command, args []string) {43		vmName := normalizeVmName(args[0])44		command := strings.Join(args[1:], " ")45		err := vms.PortForward(vmName, command)46		if err != nil {47			fmt.Println(err)48			os.Exit(1)49		}50	},51	Args: func(cmd *cobra.Command, args []string) error {52		if len(args) < 1 {53			return errors.New("vm required")54		}55		if len(args) < 2 {56			return errors.New("ports required")57		}58		return nil59	},...

portforwarding.go

Source:portforwarding.go

...5	"strconv"6	"strings"7	"github.com/pkg/errors"8)9type PortForwarding struct {10	VMName    string11	Interface int12	Name      string13	Protocol  string14	HostIP    string15	HostPort  int16	GuestIP   string17	GuestPort int18}19func (vm *VM) NewPortForwarding(name string) *PortForwarding {20	return &PortForwarding{21		VMName:    vm.Name,22		Interface: 1,23		Name:      name,24		Protocol:  "tcp",25		HostIP:    "127.0.0.1",26		HostPort:  0,27		GuestIP:   "",28		GuestPort: 0,29	}30}31func fromCSV(vmname string, iface int, csvString string) (*PortForwarding, error) {32	reader := csv.NewReader(strings.NewReader(csvString))33	fields, err := reader.Read()34	if err != nil {35		return nil, errors.Wrap(err, "could not parse csv")36	}37	if len(fields) != 6 {38		return nil, errors.New("unexpected number of fields")39	}40	hostPort, err := strconv.Atoi(fields[3])41	if err != nil {42		return nil, err43	}44	guestPort, err := strconv.Atoi(fields[5])45	if err != nil {46		return nil, err47	}48	return &PortForwarding{49		VMName:    vmname,50		Interface: iface,51		Name:      fields[0],52		Protocol:  fields[1],53		HostIP:    fields[2],54		HostPort:  hostPort,55		GuestIP:   fields[4],56		GuestPort: guestPort,57	}, nil58}59func (forward *PortForwarding) toCSV() string {60	return fmt.Sprintf(61		"%s,%s,%s,%d,%s,%d",62		forward.Name,63		forward.Protocol,64		forward.HostIP,65		forward.HostPort,66		forward.GuestIP,67		forward.GuestPort,68	)69}70func (forward *PortForwarding) Create() error {71	if forward.HostPort == 0 {72		port, err := findAvailableTCPPort()73		if err != nil {74			return err75		}76		forward.HostPort = port77	}78	vbm(79		"modifyvm", forward.VMName,80		fmt.Sprintf("--natpf%d", forward.Interface),81		"delete", forward.Name,82	)83	_, err := vbm(84		"modifyvm", forward.VMName,85		fmt.Sprintf("--natpf%d", forward.Interface),86		forward.toCSV(),87	)88	return err89}90func (vm *VM) ListPortForwardings() ([]*PortForwarding, error) {91	var result []*PortForwarding92	info, err := vm.Info()93	if err != nil {94		return result, err95	}96	for name, value := range info {97		if !strings.HasPrefix(name, "Forwarding") {98			continue99		}100		name = strings.TrimPrefix(name, "Forwarding(")101		name = strings.TrimSuffix(name, ")")102		iface, err := strconv.Atoi(name)103		if err != nil {104			return result, err105		}106		forward, err := fromCSV(vm.Name, iface, value)107		if err != nil {108			return result, err109		}110		result = append(result, forward)111	}112	return result, nil113}...

Forward

Using AI Code Generation

1import "fmt"2import "github.com/ethereum/go-ethereum/core/vm"3import "github.com/ethereum/go-ethereum/core/state"4import "github.com/ethereum/go-ethereum/core/types"5import "github.com/ethereum/go-ethereum/common"6import "github.com/ethereum/go-ethereum/params"7import "github.com/ethereum/go-ethereum/core"8import "github.com/ethereum/go-ethereum/crypto"9import "github.com/ethereum/go-ethereum/accounts/abi"10import "github.com/ethereum/go-ethereum/common/hexutil"11import "github.com/ethereum/go-ethereum/core/vm/runtime"12import "github.com/ethereum/go-ethereum/core/vm/runtime/runtime_test"13func main() {14    db := state.NewDatabase(rawdb.NewMemoryDatabase())15    state, _ := state.New(common.Hash{}, db)16    env := vm.NewEVM(vm.Context{}, state, params.TestChainConfig, vm.Config{})17    contractRef := vm.AccountRef(common.BytesToAddress([]byte("contract")))18    contract := vm.NewContract(contractRef, vm.AccountRef(common.BytesToAddress([]byte("contract"))), big.NewInt(0), 100000)19    contract.SetCallCode(&common.Address{}, common.Hex2Bytes("60016002016003016000f3"))20    evm := vm.NewEVM(vm.Context{}, state, params.TestChainConfig, vm.Config{})21    ret, _, err := evm.Call(contract, nil, 100000)22    if err != nil {23        fmt.Println(err)24    }25    fmt.Println(ret)26}27import "fmt"28import "github.com/ethereum/go-ethereum/core/vm"29import "github

Forward

Using AI Code Generation

1import (2func main() {3    vm := otto.New()4    vm.Run(`5        function add(a, b) {6            return a + b;7        }8    value, _ := vm.Run("add(2, 2)")9}10import (11func main() {12    vm := otto.New()13    vm.Set("foo", 42)14    value, _ := vm.Run("foo")15}16import (17func main() {18    vm := otto.New()19    vm.Set("foo", 42)20    value, _ := vm.Get("foo")21}22import (23func main() {24    vm := otto.New()25    vm.Run(`26        function add(a, b) {27            return a + b;28        }29    value, _ := vm.Call("add", nil, 2, 2)30}31import (32func main() {33    vm := otto.New()34    value, _ := vm.ToValue(42)35}36import (37func main() {38    vm := otto.New()39    value, _ := vm.ToValue(42.1)40    fmt.Println(value.Integer())

Forward

Using AI Code Generation

1import (2func main() {3    vm := geojson.NewVM()4    obj := geojson.NewObject(1)5    obj.SetPoint(geom.Point{0, 0})6    vm.AddObject(obj)7    obj2 := geojson.NewObject(2)8    obj2.SetPoint(geom.Point{0, 0})9    vm.AddObject(obj2)10    obj3 := geojson.NewObject(3)

Forward

Using AI Code Generation

1import (2func main() {3	vm := otto.New()4	vm.Run(`5        var a = 1;6        var b = 2;7        var c = 3;8	fmt.Println("a:", vm.Get("a"))9	fmt.Println("b:", vm.Get("b"))10	fmt.Println("c:", vm.Get("c"))11	vm.Run(`12        var d = 4;13        var e = 5;14        var f = 6;15	fmt.Println("d:", vm.Get("d"))16	fmt.Println("e:", vm.Get("e"))17	fmt.Println("f:", vm.Get("f"))18	vm.Run(`19        var g = 7;20        var h = 8;21        var i = 9;22	fmt.Println("g:", vm.Get("g"))23	fmt.Println("h:", vm.Get("h"))24	fmt.Println("i:", vm.Get("i"))25	vm.Run(`26        var j = 10;27        var k = 11;28        var l = 12;29	fmt.Println("j:", vm.Get("j"))30	fmt.Println("k:", vm.Get("k"))31	fmt.Println("l:", vm.Get("l"))32	vm.Run(`33        var m = 13;34        var n = 14;35        var o = 15;36	fmt.Println("m:", vm.Get("m"))37	fmt.Println("n:", vm.Get("n"))38	fmt.Println("o:", vm.Get("o"))39	vm.Run(`40        var p = 16;41        var q = 17;42        var r = 18;43	fmt.Println("p:", vm.Get("p"))44	fmt.Println("q:", vm.Get("q"))45	fmt.Println("r:", vm.Get("r"))46	vm.Run(`47        var s = 19;48        var t = 20;49        var u = 21;50	fmt.Println("s:", vm.Get("s"))51	fmt.Println("t:", vm.Get("t"))52	fmt.Println("u:", vm.Get("u"))53	vm.Run(`54        var v = 22;55        var w = 23;56        var x = 24;57	fmt.Println("v:", vm.Get("v"))58	fmt.Println("w:", vm.Get("w"))59	fmt.Println("x:", vm.Get("x"))60	vm.Run(`61        var y = 25;

Forward

Using AI Code Generation

1import "fmt"2type vm struct {3}4func (vm *vm) Forward() {5    fmt.Println("Forwarding port 80 to 8080")6}7func main() {8    myvm := vm{name: "myvm01", os: "linux"}9    myvm.Forward()10}11func (typeName typeName) methodName() {12}13func (typeName *typeName) methodName() {14}15func (typeName *typeName) methodName() {16}17func (typeName *typeName) methodName() {18}19func (typeName *typeName) methodName() {20}21func (typeName *typeName) methodName() {22}23func (typeName *typeName) methodName() {24}

Forward

Using AI Code Generation

1import (2func main() {3	v := vm.NewVM()4	v.Forward(5)5	fmt.Println(v)6}7import (8func main() {9	v := vm.NewVM()10	v.TurnLeft()11	fmt.Println(v)12}13import (14func main() {15	v := vm.NewVM()16	v.TurnRight()17	fmt.Println(v)18}19import (20func main() {21	v := vm.NewVM()22	v.TurnAround()23	fmt.Println(v)24}25import (26func main() {27	v := vm.NewVM()28	v.Report()29}30import (31func main() {32	v := vm.NewVM()33	v.Run()34}35import (36func main() {37	v := vm.NewVM()

Forward

Using AI Code Generation

1import (2func main() {3	fmt.Println("hello world")4	socket, err := qmp.NewSocket("unix", "/var/run/libvirt/qemu/instance-0000000a.sock", 2)5	if err != nil {6		fmt.Println(err)7	}8	conn, err := qmp.NewConn(socket)9	if err != nil {10		fmt.Println(err)11	}12	_, err = conn.Connect()13	if err != nil {14		fmt.Println(err)15	}16	defer conn.Close()17	err = conn.ExecuteQMPCapabilities()18	if err != nil {19		fmt.Println(err)20	}21}22./2.go:31: vm.Forward undefined (type *qmp.VM has no field or method Forward)

Forward

Using AI Code Generation

1import (2func main() {3	vm := virtual_machine.NewVM()4	vm.Forward(10)5	fmt.Println(vm)6}7import (8func main() {9	vm := virtual_machine.NewVM()10	vm.Left()11	fmt.Println(vm)12}13import (14func main() {15	vm := virtual_machine.NewVM()16	vm.Right()17	fmt.Println(vm)18}19import (20func main() {21	vm := virtual_machine.NewVM()22	vm.Report()23}24import (25func main() {26	vm := virtual_machine.NewVM()27	vm.Place(1, 2, "EAST")28	fmt.Println(vm)29}30import (31func main() {32	vm := virtual_machine.NewVM()33	vm.Place(1, 2, "EAST")34	vm.Move()35	fmt.Println(vm)36}37import (

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.