private static async Task <RuleSet> CreateRuleSet(LoadBalancerClient lbClient, string loadBalancerId)
{
logger.Info($"Creating new rule set: {RuleSetName}");
List <Rule> rules = new List <Rule>();
var addHttpRequestHeaderRule = new AddHttpRequestHeaderRule
{
Header = "someRequestHeader",
Value = "/example/1"
};
var extendHttpRequestHeaderValueRule = new ExtendHttpRequestHeaderValueRule
{
Header = "someRequestHeader",
Suffix = "Some-static-suffix-value",
Prefix = "Some-static-prefix-value"
};
var removeHttpResponseHeaderRule = new RemoveHttpResponseHeaderRule
{
Header = "someResponseHeader"
};
rules.Add(addHttpRequestHeaderRule);
rules.Add(extendHttpRequestHeaderValueRule);
rules.Add(removeHttpResponseHeaderRule);
var createRuleSetDetails = new CreateRuleSetDetails
{
Name = RuleSetName,
Items = rules
};
var createRuleSetRequest = new CreateRuleSetRequest
{
CreateRuleSetDetails = createRuleSetDetails,
LoadBalancerId = loadBalancerId
};
var createRuleSetResponse = await lbClient.CreateRuleSet(createRuleSetRequest);
var waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
var getWorkRequestRequest = new GetWorkRequestRequest
{
WorkRequestId = createRuleSetResponse.OpcWorkRequestId
};
lbClient.Waiters.ForWorkRequest(getWorkRequestRequest, waiterConfiguration, WorkRequest.LifecycleStateEnum.Succeeded).Execute();
logger.Info($"RuleSet: {RuleSetName} is created");
var getRuleSetRequest = new GetRuleSetRequest
{
LoadBalancerId = loadBalancerId,
RuleSetName = RuleSetName
};
var getRuleSetResponse = await lbClient.GetRuleSet(getRuleSetRequest);
return(getRuleSetResponse.RuleSet);
}
protected virtual ILoadBalanceService CreateLoadBalancerClient(DirectoryServer server, IDirectoryProvider directory)
{
ILoadBalanceService result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
LoadBalancerClient loadBalancerClient = LoadBalancerClient.Create(server.Fqdn, directory, this.logger);
disposeGuard.Add <LoadBalancerClient>(loadBalancerClient);
bool flag = true;
ILoadBalanceService loadBalanceService = loadBalancerClient;
if (!loadBalancerClient.ServerVersion[1])
{
flag = false;
loadBalanceService = this.CreateCompatibilityLoadBalanceClient(server);
}
else if (!loadBalancerClient.ServerVersion[2])
{
loadBalanceService = new SoftDeletedRemovalCapabilityDecorator(loadBalanceService, server);
}
if (!loadBalancerClient.ServerVersion[3])
{
loadBalanceService = new ConsumerMetricsLoadBalanceCapabilityDecorator(loadBalanceService, server);
}
if (!loadBalancerClient.ServerVersion[5])
{
loadBalanceService = new CapacitySummaryCapabilityDecorator(loadBalanceService, server, this.serviceContext);
}
if (flag)
{
disposeGuard.Success();
}
result = loadBalanceService;
}
return(result);
}
public static async Task MainWaiters()
{
logger.Info("Starting example");
var provider = new ConfigFileAuthenticationDetailsProvider("DEFAULT");
var compartmentId = Environment.GetEnvironmentVariable("OCI_COMPARTMENT_ID");
var loadBalancerId = Environment.GetEnvironmentVariable("LOADBALANCER_ID");
var backendSetName = Environment.GetEnvironmentVariable("BACKEND_SET_NAME");
var loadBalancerClient = new LoadBalancerClient(provider);
try
{
var ruleSet = await CreateRuleSet(loadBalancerClient, loadBalancerId);
}
catch (Exception e)
{
logger.Error($"Failed to add ruleset: {e}");
}
finally
{
loadBalancerClient.Dispose();
}
logger.Info("End example");
}
protected override void ProcessRecord()
{
base.ProcessRecord();
client?.Dispose();
client = new LoadBalancerClient(AuthProvider, new Oci.Common.ClientConfiguration
{
RetryConfiguration = retryConfig,
TimeoutMillis = TimeOutInMillis,
ClientUserAgent = PSUserAgent
});
try
{
string region = GetPreferredRegion();
if (region != null)
{
WriteDebug("Choosing Region:" + region);
client.SetRegion(region);
}
if (Endpoint != null)
{
WriteDebug("Choosing Endpoint:" + Endpoint);
client.SetEndpoint(Endpoint);
}
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
protected void ExecuteLoadBalancerDeleteMethod(object[] invokeMethodInputParameters)
{
string serviceName = (string)ParseParameter(invokeMethodInputParameters[0]);
string deploymentName = (string)ParseParameter(invokeMethodInputParameters[1]);
string loadBalancerName = (string)ParseParameter(invokeMethodInputParameters[2]);
var result = LoadBalancerClient.Delete(serviceName, deploymentName, loadBalancerName);
WriteObject(result);
}
public void CorrectRequestForGetAll()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
client.GetAll();
factory.Received().GetPaginated <Models.Responses.LoadBalancer>("load_balancers", null, "load_balancers");
}
public void CorrectRequestForCreate()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
var body = new LoadBalancer();
client.Create(body);
factory.Received().ExecuteRequest <Models.Responses.LoadBalancer>("load_balancers", null, body, "load_balancers", Method.POST);
}
public void CorrectRequestForDelete()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
client.Delete(10);
var parameters = Arg.Is <List <Parameter> >(list => (int)list[0].Value == 10);
factory.Received().ExecuteRaw("load_balancers/{id}", null, parameters, Method.DELETE);
}
public void CorrectRequestForGet()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
client.Get(15);
var parameters = Arg.Is <List <Parameter> >(list => (int)list[0].Value == 15);
factory.Received().ExecuteRequest <Models.Responses.LoadBalancer>("load_balancers/{id}", null, parameters, "load_balancers", Method.GET);
}
protected T CallClientFunction <T>(Func <ILoadBalanceService, T> func)
{
Server server = LocalServer.GetServer();
T result;
using (LoadBalancerClient loadBalancerClient = LoadBalancerClient.Create(server.Name, NullDirectory.Instance, this.logger))
{
this.logger.Log(MigrationEventType.Verbose, "Making WCF call to load balancer", new object[0]);
result = func(loadBalancerClient);
}
return(result);
}
public void CorrectRequestForRemoveForwardingRule()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
var body = new Models.Responses.ForwardingRules();
client.RemoveForwardingRule(15, body);
var parameters = Arg.Is <List <Parameter> >(list => (int)list[0].Value == 15);
factory.Received().ExecuteRaw("load_balancers/{id}/forwarding_rules", parameters, body, Method.DELETE);
}
public void CorrectRequestForAddDroplets()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
var body = new LoadBalancerDroplets();
client.AddDroplets("15", body);
var parameters = Arg.Is <List <Parameter> >(list => (string)list[0].Value == "15");
factory.Received().ExecuteRaw("load_balancers/{id}/droplets", parameters, body, Method.POST);
}
public void CorrectRequestForUpdate()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
var body = new LoadBalancer();
client.Update("15", body);
var parameters = Arg.Is <List <Parameter> >(list => (string)list[0].Value == "15");
factory.Received().ExecuteRequest <Models.Responses.LoadBalancer>("load_balancers/{id}", parameters, body, "load_balancers", Method.PUT);
}
public void CorrectRequestForRemoveDroplets()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
var body = new LoadBalancerDroplets();
client.RemoveDroplets(15, body);
var parameters = Arg.Is <List <Parameter> >(list => (int)list[0].Value == 15);
factory.Received().ExecuteRaw("load_balancers/{id}/droplets", parameters, body, Method.DELETE);
}
public void CorrectRequestForRemoveForwardingRules()
{
var factory = Substitute.For <IConnection>();
var client = new LoadBalancerClient(factory);
var requestBody = new ForwardingRulesList()
{
ForwardingRules = new List <ForwardingRule>()
{
new ForwardingRule()
}
};
client.RemoveForwardingRules("15", requestBody);
var parameters = Arg.Is <List <Parameter> >(list => (string)list[0].Value == "15");
var body = Arg.Is <ForwardingRulesList>(ls => ls.ForwardingRules.SequenceEqual(requestBody.ForwardingRules));
factory.Received().ExecuteRaw("load_balancers/{id}/forwarding_rules", parameters, body, Method.DELETE);
}
public DigitalOceanClient(string token)
{
var client = new RestClient(DigitalOceanApiUrl)
{
UserAgent = "digitalocean-api-dotnet"
};
client.AddDefaultHeader("Authorization", string.Format("Bearer {0}", token));
_connection = new Connection(client);
Account = new AccountClient(_connection);
Actions = new ActionsClient(_connection);
CdnEndpoints = new CdnEndpointsClient(_connection);
Certificates = new CertificatesClient(_connection);
ContainerRegistry = new ContainerRegistryClient(_connection);
Databases = new DatabasesClient(_connection);
DomainRecords = new DomainRecordsClient(_connection);
Domains = new DomainsClient(_connection);
DropletActions = new DropletActionsClient(_connection);
Droplets = new DropletsClient(_connection);
Firewalls = new FirewallsClient(_connection);
FloatingIpActions = new FloatingIpActionsClient(_connection);
FloatingIps = new FloatingIpsClient(_connection);
ImageActions = new ImageActionsClient(_connection);
Images = new ImagesClient(_connection);
LoadBalancers = new LoadBalancerClient(_connection);
Projects = new ProjectsClient(_connection);
ProjectResources = new ProjectResourcesClient(_connection);
Keys = new KeysClient(_connection);
Kubernetes = new KubernetesClient(_connection);
Regions = new RegionsClient(_connection);
Sizes = new SizesClient(_connection);
Snapshots = new SnapshotsClient(_connection);
Tags = new TagsClient(_connection);
Volumes = new VolumesClient(_connection);
VolumeActions = new VolumeActionsClient(_connection);
BalanceClient = new BalanceClient(_connection);
Vpc = new VpcClient(_connection);
}
private static async Task CreateListener(LoadBalancerClient lbClient, string loadBalancerId, RuleSet ruleSet, string backendSetName)
{
logger.Info($"Creating new listener: {ListenerName} with ruleset: {RuleSetName}");
var ruleSetNames = new List <string>()
{
ruleSet.Name
};
var createListenerDetails = new CreateListenerDetails
{
Name = ListenerName,
DefaultBackendSetName = backendSetName,
Port = ListenerPort,
Protocol = ListenerProtocol,
RuleSetNames = ruleSetNames
};
var createListenerRequest = new CreateListenerRequest
{
CreateListenerDetails = createListenerDetails,
LoadBalancerId = loadBalancerId
};
var response = await lbClient.CreateListener(createListenerRequest);
var waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
var getWorkRequestRequest = new GetWorkRequestRequest
{
WorkRequestId = response.OpcWorkRequestId
};
lbClient.Waiters.ForWorkRequest(getWorkRequestRequest, waiterConfiguration, WorkRequest.LifecycleStateEnum.Succeeded).Execute();
logger.Info($"listener {ListenerName} is created");
}
public DigitalOceanClient(string token)
{
var client = new RestClient(DigitalOceanApiUrl)
{
UserAgent = "digitalocean-api-dotnet"
};
client.AddDefaultHeader("Authorization", string.Format("Bearer {0}", token));
_connection = new Connection(client);
Actions = new ActionsClient(_connection);
DomainRecords = new DomainRecordsClient(_connection);
Domains = new DomainsClient(_connection);
DropletActions = new DropletActionsClient(_connection);
Droplets = new DropletsClient(_connection);
ImageActions = new ImageActionsClient(_connection);
Images = new ImagesClient(_connection);
LoadBalancers = new LoadBalancerClient(_connection);
Keys = new KeysClient(_connection);
Regions = new RegionsClient(_connection);
Sizes = new SizesClient(_connection);
Tags = new TagsClient(_connection);
}
public LoadBalancerPaginators(LoadBalancerClient client)
{
this.client = client;
}
public LoadBalancerWaiters(LoadBalancerClient client)
{
this.client = client;
}
IEnumerator JoinSessionRoutine(UdpSession session, System.Object token)
{
Timer timer;
ChangeState(ConnectState.JoinRoomPending);
LoadBalancerClient.OpJoinRoom(session.HostName); //does this need to be done after we fail connecting too?
// request new session list from zeus
//
timer = new Timer(ROOM_JOIN_TIMEOUT);
while (_lbClient.State != ClientState.Joined && timer.Waiting)
{
yield return(null);
}
if (_lbClient.State != ClientState.Joined)
{
_currentConnectRoutine = null;
BoltLog.Error("Failed to join room");
ChangeState(ConnectState.Idle);
yield break;
}
Zeus.RequestSessionList();
yield return(new WaitForSeconds(5f));
// if we have a zeus session available for this
Debug.Log("usePunch: " + _config.UsePunchThrough);
if (_config.UsePunchThrough)
{
var s = (PhotonSession)session;
if (s._socketPeerId != Guid.Empty)
{
UdpSession zeusSession;
Debug.Log("Sessions: looking for: " + s._socketPeerId.ToString());
foreach (var se in BoltNetwork.SessionList)
{
Debug.Log("session: " + se.Key.ToString() + " : " + se.Value.Source.ToString());
}
bool tryFind = BoltNetwork.SessionList.TryFind(s._socketPeerId, out zeusSession);
Debug.Log("tryFind: " + tryFind);
if (tryFind && zeusSession.Source == UdpSessionSource.Zeus)
{
ChangeState(ConnectState.DirectPending);
#if TEST_FAIL
BoltNetwork.Connect(new UdpEndPoint(new UdpIPv4Address(0, 45, 0, 0), unchecked ((ushort)-1)));
#else
Debug.Log("PhotonPoller::PreConnectDirect");
BoltNetwork.Connect(zeusSession, token as Bolt.IProtocolToken);
Debug.Log("PhotonPoller::PosConnectDirect");
#endif
while (_connectState == ConnectState.DirectPending)
{
yield return(null);
}
if (_connectState == ConnectState.DirectSuccess)
{
ChangeState(ConnectState.Idle);
yield break;
}
}
}
}
_currentConnectRoutine = null;
//added
if (_lbClient.State != ClientState.Joined)
{
ChangeState(ConnectState.JoinRoomPending);
LoadBalancerClient.OpJoinRoom(session.HostName); //does this need to be done after we fail connecting too?
timer = new Timer(ROOM_JOIN_TIMEOUT);
while (_lbClient.State != ClientState.Joined && timer.Waiting)
{
yield return(null);
}
}
if (_lbClient.State != ClientState.Joined)
{
_currentConnectRoutine = null;
Debug.Log("Failed to join room");
//need callbacks to hook into for if joining a room failed..can we just listen for changes to the ClientState directly
//in the OnlineSetup scene... what if the room disconnects mid game?? (make callbacks in network manager too that are separate?
ChangeState(ConnectState.Idle);
yield break;
}
ChangeState(ConnectState.RelayPending);
Debug.Log("PhotonPoller::PreConnectRelay");
Debug.Log("PhotonPoller::LBClientState: " + _lbClient.State);
BoltNetwork.Connect(new UdpEndPoint(new UdpIPv4Address((uint)HostPlayerId), 0), token as Bolt.IProtocolToken);
Debug.Log("PhotonPoller::PostConnectRelay");
while (_connectState == ConnectState.RelayPending)
{
yield return(null);
}
if (_connectState == ConnectState.RelayFailed)
{
Debug.Log("-- THIS SHOULDN'T HAPPEN -- Connecting to photon room '{0}' failed " + session.HostName);
}
ChangeState(ConnectState.Idle);
}
IEnumerator JoinSessionRoutine(UdpSession session, Bolt.IProtocolToken token)
{
Timer timer;
ChangeState(ConnectState.JoinRoomPending);
LoadBalancerClient.OpJoinRoom(session.HostName);
// request new session list from zeus
Zeus.RequestSessionList();
//
timer = new Timer(ROOM_JOIN_TIMEOUT);
while (_lbClient.State != ClientState.Joined && timer.Waiting)
{
yield return(null);
}
if (_lbClient.State != ClientState.Joined)
{
_currentConnectRoutine = null;
BoltLog.Error("Failed to join room");
ChangeState(ConnectState.Idle);
yield break;
}
// if we have a zeus session available for this
if (_config.UsePunchThrough)
{
var s = (PhotonSession)session;
if (s._socketPeerId != Guid.Empty)
{
UdpSession zeusSession;
if (BoltNetwork.SessionList.TryFind(s._socketPeerId, out zeusSession) && zeusSession.Source == UdpSessionSource.Zeus)
{
ChangeState(ConnectState.DirectPending);
#if TEST_FAIL
BoltNetwork.Connect(new UdpEndPoint(new UdpIPv4Address(0, 45, 0, 0), unchecked ((ushort)-1)));
#else
BoltNetwork.Connect(zeusSession);
#endif
while (_connectState == ConnectState.DirectPending)
{
yield return(null);
}
if (_connectState == ConnectState.DirectSuccess)
{
ChangeState(ConnectState.Idle);
yield break;
}
}
}
}
_currentConnectRoutine = null;
ChangeState(ConnectState.RelayPending);
BoltNetwork.Connect(new UdpEndPoint(new UdpIPv4Address((uint)HostPlayerId), 0), token);
while (_connectState == ConnectState.RelayPending)
{
yield return(null);
}
if (_connectState == ConnectState.RelayFailed)
{
BoltLog.Error("Connecting to photon room '{0}' failed", session.HostName);
}
ChangeState(ConnectState.Idle);
}
public static void ConsoleDisplay(ClientConfig config)
{
var identityClient = new IdentityClient(config)
{
Region = Regions.US_ASHBURN_1
};
var lbClient = new LoadBalancerClient(config);
var listCompartmentRequest = new ListCompartmentRequest()
{
CompartmentId = config.TenancyId,
CompartmentIdInSubtree = true,
AccessLevel = ListCompartmentRequest.AccessLevels.ACCESSIBLE
};
var compartments = identityClient.ListCompartment(listCompartmentRequest).Items;
Console.WriteLine("* LB Resources------------------------");
foreach (var com in compartments)
{
if (com.LifecycleState != "ACTIVE")
{
continue;
}
Console.WriteLine($" Compartment<{com.Name}>--------");
var listLoadBalancersRequest = new ListLoadBalancersRequest()
{
CompartmentId = com.Id,
SortBy = ListLoadBalancersRequest.SortByParam.DISPLAYNAME
};
Console.WriteLine(" LoadBalancer------");
var loadbalancers = lbClient.ListLoadBalancers(listLoadBalancersRequest).Items;
foreach (var lb in loadbalancers)
{
var getLoadBalancerRequest = new GetLoadBalancerRequest()
{
LoadBalancerId = lb.Id
};
var lbDetail = lbClient.GetLoadBalancer(getLoadBalancerRequest).LoadBalancer;
Console.WriteLine($"\t|- displayName: {lbDetail.DisplayName}");
Console.WriteLine($"\t| state: {lbDetail.LifecycleState}");
Console.WriteLine($"\t| shape: {lbDetail.ShapeName}");
Console.WriteLine($"\t| timeCreated: {lbDetail.TimeCreated}");
Console.WriteLine($"\t| ipAddresses: {lbDetail.IpAddresses}");
Console.WriteLine($"\t| private: {lbDetail.IsPrivate}");
Console.WriteLine($"\t| listeners:");
foreach (var key in lbDetail.Listeners.Keys)
{
Console.WriteLine($"\t| |-{key} : {lbDetail.Listeners[key].DefaultBackendSetName}");
}
Console.WriteLine($"\t| rules:");
foreach (var key in lbDetail.RuleSets.Keys)
{
Console.WriteLine($"\t| |-{lbDetail.RuleSets[key].Name}");
foreach (var rule in lbDetail.RuleSets[key].Items)
{
Console.WriteLine($"\t| | |-{rule.Action}");
}
}
Console.WriteLine($"\t| workRequest:");
var listWorkRequestsRequest = new ListWorkRequestsRequest()
{
LoadBalancerId = lb.Id
};
var works = lbClient.ListWorkRequests(listWorkRequestsRequest).Items;
foreach (var work in works)
{
Console.WriteLine($"\t| |-{work.Type}");
Console.WriteLine($"\t| | {work.LifecycleState}");
}
}
Console.WriteLine(" LoadBalancerHealth------");
var listLoadBalancerHealthsRequest = new ListLoadBalancerHealthsRequest()
{
CompartmentId = com.Id
};
var lbHealths = lbClient.ListLoadBalancerHealths(listLoadBalancerHealthsRequest).Items;
foreach (var health in lbHealths)
{
var getLoadBalancerHealthRequest = new GetLoadBalancerHealthRequest()
{
LoadBalancerId = health.LoadBalancerId
};
var healthDetail = lbClient.GetLoadBalancerHealth(getLoadBalancerHealthRequest).LoadBalancerHealth;
Console.WriteLine($"\t|- criticalStateBackendSetNames:");
foreach (var name in healthDetail.CriticalStateBackendSetNames)
{
Console.WriteLine($"\t| |-{name}");
}
Console.WriteLine($"\t|- unknownStateBackendSetNames:");
foreach (var name in healthDetail.UnknownStateBackendSetNames)
{
Console.WriteLine($"\t| |-{name}");
}
Console.WriteLine($"\t|- warningStateBackendSetNames:");
foreach (var name in healthDetail.WarningStateBackendSetNames)
{
Console.WriteLine($"\t| |-{name}");
}
}
Console.WriteLine(" LoadBalancerPolicy------");
var listLoadBalancerPoliciesRequest = new ListLoadBalancerPoliciesRequest()
{
CompartmentId = com.Id
};
var lbPolicies = lbClient.ListLoadBalancerPolicies(listLoadBalancerPoliciesRequest).Items;
foreach (var policy in lbPolicies)
{
Console.WriteLine($"\t|- name: {policy.Name}");
}
Console.WriteLine(" LoadBalancerProtocol------");
var listLoadBalancerProtocolsRequest = new ListLoadBalancerProtocolsRequest()
{
CompartmentId = com.Id
};
var lbProtocols = lbClient.ListLoadBalancerProtocols(listLoadBalancerProtocolsRequest).Items;
foreach (var protocol in lbProtocols)
{
Console.WriteLine($"\t|- name: {protocol.Name}");
}
Console.WriteLine(" LoadBalancerShape------");
var listLoadBalancerShapesRequest = new ListLoadBalancerShapesRequest()
{
CompartmentId = com.Id
};
var lbShapes = lbClient.ListLoadBalancerShapes(listLoadBalancerShapesRequest).Items;
foreach (var shape in lbShapes)
{
Console.WriteLine($"\t|- name: {shape.Name}");
}
}
}
