This weekend, I came across with an awkward error that I was not able to access https urls or ssl/tls based services while I was able to access non-tls based services over tcp without any problem inside a container.

First, I taught it was a TLS communication error and start digging around container image base, configurations, ca certificates and etc... But nothing worked. I was right it was a TLS communication error but not at the process level. Before I got into this error, I set up Wireguard Vpn which I added recently into my setup. So I stop working around wiring new container files and changed my way to other part of the setup.

Solution

The setup that my docker daemon was running on a host which was configured with Wireguard VPN. So I started troubleshooting on the network stack and boom...

~# ip link

X: wg0: <POINTOPOINT,NOARP,UP,LOWER_UP> mtu 1420 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/none
X: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN mode DEFAULT group default
    link/ether XX:XX:XX:XX:XX:XX brd ff:ff:ff:ff:ff:ff

The problem was because of different MTU sizes on the docker and wg* interfaces.

The Docker Daemon does not check the MTU size of the any available network interfaces. Therefore, the value of the Docker MTU was set to 1500. When I change MTU size of docker0 interface to 1420 that matches the wireguard default MTU size, everything started working again.

Wireguard Docker Repository

It is also mentioned under others section on the repository.

For some clients (a GL.inet router in my case) you may have trouble with HTTPS (SSL/TLS) due to the MTU on the VPN. Ping and HTTP work fine but HTTPS does not for some sites.

This can be fixed with MSS Clamping. This is simply a checkbox in the OpenWRT Firewall settings interface.

https://github.com/cmulk/wireguard-docker

You can find more information on wireguard-docker repository.

Docker Daemon Configuration

/etc/docker/daemon.json

{
  "mtu": 1420
}

Restart the docker daemon and we are all set. If the output of MTU size doesn't update suddenly, make sure you have run a container after the configuration.

Asynchronous server application is not suspended while it waits for a connection from a client. If we spin up threads for each session, then the server waits for the IO operations which we don't want. This example project shows handling tcp sockets Asynchronously without running separate threads for each session. The example async socket server is available on github.

Getting Started

Requirements

• Java 8
• Maven

Project Setup

1. Clone Repository

git clone https://github.com/deluxetiky/java-async-socket-server
cd java-async-socket-server

2. Build Project

mvn compile

[INFO] 
[INFO] ----------------< org.example:java-async-socket-sample >----------------
[INFO] Building java-async-socket-sample 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ java-async-socket-sample ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 1 resource
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ java-async-socket-sample ---
[INFO] Nothing to compile - all classes are up to date
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS

3. Spin-Up Server

mvn exec:java -Dexec.mainClass="Server.SocketStandAlone"

[INFO] 
[INFO] ----------------< org.example:java-async-socket-sample >----------------
[INFO] Building java-async-socket-sample 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- exec-maven-plugin:1.6.0:java (default-cli) @ java-async-socket-sample ---
2020-03-27 21:16:39 INFO  SocketServer:30 - Device socket server started on /0.0.0.0:5050

4. Finish

We can spin up multiple concurrent sessions with telnet. Our server will be pushing back to same data that we sent.

telnet localhost 5050

Project repository. That was a quick one. So hope I will come back and explain the code in the repository more detailed.    

Today, We will create simple Apache Flink stateful streaming word count application to show you up how powerful apis it has and easy to write stateful applications. Stream processing is one of the most important component of modern data driven application pipelines. There is a nice article here which is more about the use cases, stateful term definitions and business values of it. In this article I want to focus more on stateful scenario .

This picture shows really nice how its architecture differs from traditional application pipelines. There are not many examples to the Flink on the internet. That's why I decided to write this article. Especially, for the stateful streaming part, tons of papers are around... Okay it's enough for the intro, let's get hands on dirty...

Sample Scenario

In this example, I will create word count stream analytics pipeline which has two inputs that are used for data ingestion and dynamic filtering. While one input ingests stream of words, the other sets the filtering criteria of the the pipeline dynamically. The input filter stream updates the current state in the co-process function where our logic is implemented. After joining two streams together, the co-process function applies filtering condition based on the state updated with the input filter stream. Afterwards, we'll apply sliding window function that has 5 seconds size with 1 second sliding interval. The result of all this pipeline goes into one output sink which is tcp socket connection in our case.

Project Setup

You can set up Flink environment quickly by visiting this link.After you complete that step, we are ready to create our project. I'll use maven quick start template

$mvn archetype:generate -DarchetypeGroupId=org.apache.flink \
-DarchetypeArtifactId=flink-quickstart-java \
-DarchetypeVersion=1.6.0 \
-DgroupId=com-streaming-example \
-DartifactId=com-streaming-example \
-Dversion=1.0 \
-Dpackage=com.sinanbir.example

After this step, our project basic structure will be ready for us. We will be using Rocks Db state backend. It's not added as a default package in quick start template. So, to use this package you should add it to your dependencies by adding following line into pom.xml

<dependencies>
  ...	
    <dependency>
			<groupId>org.apache.flink</groupId>
			<artifactId>flink-statebackend-rocksdb_2.11</artifactId>
			<version>1.6-SNAPSHOT</version>
    </dependency>
  ...
</dependencies>

After we complete the setup above. The project structure will be like in the picture.

Application Code

public class StreamingJob{

	public static void main(String[] args) throws Exception{

		final ParameterTool params = ParameterTool.fromArgs(args);
		int portWordStream = params.getInt("portStream");
		int portFilterStream = params.getInt("portFilterStream");
		int portSink = params.getInt("portSink");
		String stateDir = params.get("stateDir");
		String socketHost = params.get("host");

		final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
		env.setStateBackend(new RocksDBStateBackend(stateDir, false));
		env.enableCheckpointing(2000);// start a checkpoint every 2seconds
		CheckpointConfig config = env.getCheckpointConfig();
		config.setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);// set mode to exactly-once (this is the default)
		config.enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);

		DataStream<Tuple2<String,Integer>> wordStream = env
				.socketTextStream(socketHost, portWordStream).name("Word Stream")
				.setParallelism(1)
				.flatMap(new WordStreamParser()).name("Word FlatMap")
				.keyBy(0);

		DataStream<Tuple2<String,Boolean>> filterStream = env
				.socketTextStream(socketHost, portFilterStream).name("Filter Stream")
				.setParallelism(1)
				.flatMap(new FilterStreamParser()).name("Filter FlatMap")
				.keyBy(0);

		DataStream<Tuple2<String,Integer>> joinedStream = wordStream
				.connect(filterStream)
				.process(new JoinProcessFunction()).setParallelism(5).uid("join-1").name("Co-JoinProcess")
				.keyBy(0)
				.window(SlidingProcessingTimeWindows.of(Time.seconds(5), Time.seconds(1)))
				.sum(1).name("Summarize")
				.setParallelism(5);

		joinedStream.map((MapFunction<Tuple2<String,Integer>,String>)input -> String.format("%tT | %s Count: %d\
", LocalDateTime.now(), input.f0, input.f1))
				.returns(String.class)
				.writeToSocket(socketHost, portSink, new SimpleStringSchema())
				.setParallelism(1)
				.name("Socket Output");


		// execute program
		env.execute("Flink Streaming Stateful Java Example");
	}
}

Between line 14-18 we configured our application to keep its state at file system with Rocksdb state backend. I set the check interval 2 seconds for test purposes.  At line 18, we specified that even we cancelled the job, state should be retained. I kept the state cause I'll show you how to re-deploy application that continuous from existing state.  I won't go details of this configurations too much because more detailed different settings depend on your program flow. The important part here is that we set explicitly we want to keep our state at the file system with a Rocksdb state backend. Further information can be found here.   The rest of the code defines how our pipeline process events. I wanna mention some important part here, at the end of some functions I set parallelism explicitly. For example, at the first stage of our code  I set parallelism to one cause I will use netcat for the socket listening part and It can not listen tcp connections in broker mode. If the source was different like Kafka, it wouldn't be problem.  It is similar for the output socket sink.

Note: If you deploy an application that requires more task resources than the cluster has, deployment stucks at starting. I had similar problem when I want to deploy an app unless I change the taskmanager.numberOfTaskSlots number more than my application requirements in the flink-conf.yaml.

An other important point is we set the event time to ProcessingTime which is directly related with our windowing function selection. We used SlidingProcessingTimeWindows which doesn't work with EventTime. However, we can still override watermark settings with custom implementation to overcome this but this is not necessary in our example.   In this example, there are two different flat-map implementation which are mapping socket text stream data to flink's tuple class type.The type Tuple is preferred just for development purposes. If you want, you can implement your own custom POJOs.

public class WordStreamParser implements FlatMapFunction<String,Tuple2<String,Integer>>{
	@Override
	public void flatMap(String s, Collector<Tuple2<String,Integer>> collector) throws Exception{
		for(String word : s.trim().split(" ")) {
			collector.collect(Tuple2.of(word, 1));
		}
	}
}

Here, we split string to words and assign each word 1.

public class FilterStreamParser implements FlatMapFunction<String,Tuple2<String,Boolean>>{
	@Override
	public void flatMap(String s, Collector<Tuple2<String,Boolean>> collector) throws Exception{
		String[] strVals = s.split("=");
		if(strVals.length == 2){
			String key = strVals[0];
			Boolean val = strVals[1].equals("1") || strVals[1].equals("true");
			collector.collect(Tuple2.of(key, val));
		}
	}
}

Here we defined a scheme that works only when the input is in the format of -> word=0 -> word=1 -> word=true Now it's time to explain how are we going to join these two streams together while we keep the current state sync. Let me explain this with the code

public class JoinProcessFunction extends CoProcessFunction<Tuple2<String,Integer>,Tuple2<String,Boolean>,Tuple2<String,Integer>>{
	private ValueState<FilterState> state;

	@Override
	public void open(Configuration parameters) throws Exception{
		ValueStateDescriptor<FilterState> desc = new ValueStateDescriptor<>(
				"filterState",
				FilterState.class, new FilterState(true)
		);
		state = getRuntimeContext().getState(desc);
	}

	@Override
	public void processElement1(Tuple2<String,Integer> input, Context context, Collector<Tuple2<String,Integer>> collector) throws Exception{
		String key = input.f0;
		FilterState current = state.value();
		if(current.Active) collector.collect(input);//filtering place
	}

	@Override
	public void processElement2(Tuple2<String,Boolean> input, Context context, Collector<Tuple2<String,Integer>> collector) throws Exception{
		FilterState current = state.value();
		current.Active = input.f1;//set state value
		state.update(current);
	}
}

The co-process function is bound two different inputs. In our case, processElement1 is called whenever we receive an event from word stream socket and it checks whether the word is activated or not. The function class manages the life cycle of the state. Before we connected two stream together we called keyBy function to distribute tasks based on the key which is word. When we called state.value() we get state of the key that we set with the keyBy. Second input ( filter stream ) only updates the state itself. It doesn't emit any data.This is really nice capability. You can implement any low level join or other stateful processing functions. The flink api itself takes care of distributing the state among the task managers. So you just focus on your application business logic. More detailed information can be found here.

Deployment & Running

So far, we've have explained what is our application about and mentioned some apis of the Flink. Now, we'll deploy and run our application. We'll use flink cli to deploy and run our application after we compiled application artifacts.

mvn package

It will build com-streaming-example-1.0.jar file in the target directory. Before sending our job to flink we need to open socket listeners. I'll use netcat tool for the running tcp listener on my local environment.

nc -L localhost -p <port> // filter stream
nc -L localhost -p <port> // word stream
nc -L localhost -p <port> // output sink

After we run our tcp listeners, we can send our application to flink local cluster with command below. In my demo I preferred port 9002, 9003 and 9004.

bin\flink run -c com.sinanbir.example.StreamingJob <com-streaming-example-1.0.jar - Path>  --portStream <port> --portFilterStream <port> --portSink 9004 --host <host>  --stateDir <statedirectory path file:///>

Now our job has been submitted successfully.ıf your application doesn't start, make sure that all of the listeners are working properly. Now,It's time to test our stream pipeline. As you can see the words which have been disabled are not buffered to window summarize function and sliding window results are as expected. In an other article I'll show an example of how to redeploy an existing application and run it from its previous state. You can access all of the code base from here.            

  It is the practice that requires developers to integrate the code into a shared repository at least once a day. The integration is followed up by a build and test steps to solve problems quickly. Then you can fix the problems easily before they get serious. It would be hard to find and fix them on the repository where the developers don't integrate their changes so often. When they do, they will be able to add new features instead of spending more time on debugging. Everyone can see what is happening on the repository. Unit and Integration tests have important roles on that pipeline. Overall, reduced risks, release more often and provide higher quality products.

“Continuous Integration doesn’t get rid of bugs, but it does make them dramatically easier to find and remove.”

— Martin Fowler, Chief Scientist, ThoughtWorks

Continuous Delivery vs Deployment

Satisfying customers feedback on the production is important. Continuous Delivery is the discipline where the software can be released to production when there is a change on the code  or configuration. Your application can benefit from this while providing you always production ready software. So what is the difference between delivery and the deployment ? Continuous delivery is the pipeline where the release is controlled manually whereas continuous deployment is the pipeline which is sequences of automated steps. The changes are always released to the production in continuous deployment. However it requires continuous delivery. So they are the terms which are used for each other by mistake. CD vs CI    

Setup Projects

I will be using Visual Studio 2017 as my IDE.  You need .netCore framework installed before. Later on, we are going to test our identity api with my favorite tool PostMan.

• Lets create our .netCore api project.
• Then select empty template
• In program.cs file add

  UseUrls("http://localhost:8000")

Install Identity Server package "Abp.ZeroCore.IdentityServer4" with nuget package manager. After installation you will have package reference in your csproj file like below.

•   <ItemGroup> <PackageReference Include="Abp.ZeroCore.IdentityServer4" Version="3.2.5" /> <PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.3" /> </ItemGroup>

• We are going to configure IdentityServer to use MemoryStore for test purposes. In production you shouldn't use it in that way. Let's create MemoryDb.cs file to store our client and resource information. IdentityServer also has support for EF. More information could be found on identity server website.

  using IdentityServer4;
  using IdentityServer4.Models;
  using IdentityServer4.Test;
  using System.Collections.Generic;
  
  namespace WebApp.IdentityServer.Example.Helper
  {
  	public class MemoryDb
  	{
  		// scopes define the API resources in your system
  		public static IEnumerable<ApiResource> GetApiResources()
  		{
  			return new List<ApiResource>
  			{
  				new ApiResource("sinanbir.com.auth", "My API Display Name")
  			};
  		}
  
  		// clients
  		public static IEnumerable<Client> GetClients()
  		{
  			// client credentials client
  			return new List<Client>
  			{
  				new Client
  				{
  					ClientId = "client1",
  					AllowedGrantTypes = GrantTypes.ClientCredentials,
  
  					ClientSecrets =
  					{
  						new Secret("password".Sha256())
  					},
  					AllowedScopes = { "sinanbir.com.auth" }
  				},
   
                  // resource owner password grant client
                  new Client
  				{
  					ClientId = "ropcclient",
  					AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
  					AllowOfflineAccess = true,//Enables refresh token.
                      ClientSecrets =
  					{
  						new Secret("password".Sha256())
  					},
  					AllowedScopes = { "sinanbir.com.auth", IdentityServerConstants.StandardScopes.OfflineAccess, }
  				}
  			};
  		}
  
  		public static List<TestUser> GetUsers()
  		{
  			return new List<TestUser>
  			{
  				new TestUser
  				{
  					SubjectId = "1",
  					Username = "sinan",
  					Password = "bir"
  				},
  				new TestUser
  				{
  					SubjectId = "2",
  					Username = "testuser",
  					Password = "password"
  				}
  			};
  		}
  	}
  }
  

  "ropcclient" will be able to use refresh token by adding IdentityServerConstants.StandardScopes.OfflineAccess to its allowed scopes. You will get invalid scope error if you don't specify this scope. It's important!  

Lastly, We should modify our startup.cs file to run server and token validation. If you're migrating from asp.net core 1.x to 2.x some functions get replaced. Before 2.x release we were able to use app.UseIdentityServerAuthentication method in Configure section but it's replaced with app.UseAuthentication method. Identity server will be enabled after adding app.UseIdentityServer method in Configure section. It requires some service configurations before setting up server. We will be registering Memory implemented class into services pipeline.

services.AddIdentityServer() .AddDeveloperSigningCredential() .AddInMemoryApiResources(MemoryDb.GetApiResources()) .AddInMemoryClients(MemoryDb.GetClients()) .AddTestUsers(MemoryDb.GetUsers());

The first method AddIdentityServer adds default IdentiyServer services to the DI system. AddDeveloperSigningCredential method adds temporary key at  startup. If you don't have certificate it's easy for testing purposes. AddInMemoryApiResources method adds our memory implementation resources to identity server settings. AddInMemoryClients method adds our memory client to the identity server. AddTestUsers adds memory users to the server. If you want to change memory implementation of the user store, you should call AddAspNetIdentity<User> method. It will be looking for the service IUserStore<User>.   After registering dependencies into DI service, we'll be setting JWT Bearer options in ConfigureServices section for token validation. This settings will be used to validate our JWT token. If you're setting up a seperate identity server you don't have to configure this part. It will be only responsible to validating our tokens. First part is enough to setup our identity server for implementing openid and oauth2. But in our example we won't be setting up separate auth and api projects. So we'll be implementing them together in one solution. After completing the steps above you will have a startup.cs 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
using WebApp.IdentityServer.Example.Helper;

namespace WebApp.IdentityServer.Example
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {


			var authUrl = "http://localhost:8000";

			#region IdentityServerSetup

			services.AddIdentityServer()
				.AddDeveloperSigningCredential()
				.AddInMemoryApiResources(MemoryDb.GetApiResources())
				.AddInMemoryClients(MemoryDb.GetClients())
				.AddTestUsers(MemoryDb.GetUsers());

			#endregion

			#region Validation Settings
			services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
			.AddJwtBearer(options =>
			{
				options.Authority = authUrl;
				options.RequireHttpsMetadata = false;
				options.TokenValidationParameters = new TokenValidationParameters
				{
					ValidateIssuer = true,
					ValidIssuer = authUrl,
					ValidateAudience = false,
					ValidAudience = "sinanbir.com.auth",//test purposes
					ValidateLifetime = true,
				};
			});

			#endregion
			services.AddMvc();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

			
			app.UseIdentityServer();
			app.UseAuthentication();
			app.UseMvc();
        }
    }
}

Now our server is ready for both providing tokens and validating them.

Testing Server

Let's test our server. If you did all steps above properly then you should be able to see our server configuration by doing get request to http://localhost:8000/.well-known/openid-configuration end-point.

{
  "issuer": "http://localhost:8000",
  "jwks_uri": "http://localhost:8000/.well-known/openid-configuration/jwks",
  "authorization_endpoint": "http://localhost:8000/connect/authorize",
  "token_endpoint": "http://localhost:8000/connect/token",
  "userinfo_endpoint": "http://localhost:8000/connect/userinfo",
  "end_session_endpoint": "http://localhost:8000/connect/endsession",
  "check_session_iframe": "http://localhost:8000/connect/checksession",
  "revocation_endpoint": "http://localhost:8000/connect/revocation",
  "introspection_endpoint": "http://localhost:8000/connect/introspect",
  "frontchannel_logout_supported": true,
  "frontchannel_logout_session_supported": true,
  "scopes_supported": [
    "myApi",
    "offline_access"
  ],
  "claims_supported": [],
  "response_types_supported": [
    "code",
    "token",
    "id_token",
    "id_token token",
    "code id_token",
    "code token",
    "code id_token token"
  ],
  "response_modes_supported": [
    "form_post",
    "query",
    "fragment"
  ],
  "grant_types_supported": [
    "authorization_code",
    "client_credentials",
    "refresh_token",
    "implicit",
    "password"
  ],
  "subject_types_supported": [
    "public"
  ],
  "id_token_signing_alg_values_supported": [
    "RS256"
  ],
  "token_endpoint_auth_methods_supported": [
    "client_secret_basic",
    "client_secret_post"
  ],
  "code_challenge_methods_supported": [
    "plain",
    "S256"
  ]
}

The postman collection that I've used for tests can be reached from here.

RefreshToken Test

We'll be renewing our token for the next request by changing the grant type password to refresh_token along with the refresh_token that we get from this request.

The repo which I created for this article can be reached from here.   That's it. It's just quick setup to show how easy it is with IdentityServer. If you are looking for more samples, you can check out github repo.  

I will share the Simpson's 3 8 Method C Code. There are other methods that can calculate the integration more accurate but today I'll share one of my class notes which can be helpful who is looking for an easy implementation of this method. The function that I use for this program is e^x whose integration is same as itself. You can implement your custom function easily overriding  f(double x) prototype. Program requires lower, upper bound of integration and the n ( part count ) as an input. You can get more accurate results when you give n is high enough. Because the method is applied each part independently. You can check out code of the program below. The method detailed information.

#include <stdio.h>
#include <stdlib.h>
#define _USE_MATH_DEFINES
#include <math.h>


double  lower,upper;
int step;

double f(double x);
double simpson(double lower, double upper);
int main() {
	printf("Please enter lower bound:");
	scanf("%lf", &lower);
	printf("Please enter upper bound:");
	scanf("%lf", &upper);
	printf("Please enter n:");
	scanf("%d", &step);
	double result=0;
	
	double functionIncrement= (upper - lower)/ step;
	
	for (int i = 0; i < step; i++)
	{
		double low = lower + i*functionIncrement;
		double up = low + functionIncrement;
		result += simpson(low, up);
		printf("%lf %lf\
", low, up);

	}
	
	printf("Integration result is: %.10lf\
", result);
	system("PAUSE");
	return 0;
}

double f(double x){
	return pow(M_E,x);
}

double simpson(double lower, double upper)//n=3 3/8 kuralı
{
	double h = (upper - lower) / 3;
	double mid = lower + h;
	double mid2 = mid + h;
	double res = (3 * h / 8)*(f(lower) + 3 * f(mid) + 3 * f(mid2) + f(upper)) - 3*pow(h,5)/80;
	return res;
}

An example output when you run the program above. Lower Bound : 1 Upper Bound : 4 n : 18 Result of the integration is : 51.8798740205 When you take the original function integration it gives us 51.8798682046852. It shows that fault tolerance is in 4 decimal precision. When we give n : 100 The result becomes more accurate like 51.8798682108.

where no two are the same, the Lagrange Interpolation form is a linear combination

of Lagrange basis polynomials

where . Note how, given the initial assumption that no two are the same, , so this expression is always well-defined. The reason pairs with are not allowed is that no interpolation function such that would exist; a function can only get one value for each argument . On the other hand, if also , then those two points would actually be one single point. For all , includes the term in the numerator, so the whole product will be zero at :

On the other hand,

In other words, all basis polynomials are zero at , except , for which it holds that , because it lacks the term. It follows that , so at each point , , showing that interpolates the function exactly. ( Definition Source : Wikipedia )   The Lagrange Interpolation C Code is written below.

#include <stdio.h>
#include <stdlib.h>

double Lagrange(int n, int k,double value);
double* fx;
double* x;
double Calculate(int n, double x);
void main() {
	int size;
	double question;
	printf("Please enter function's point count:\
");
	scanf("%d", &size);

	fx = (double*)malloc(sizeof(double)*size);
	x = (double*)malloc(sizeof(double)*size);
	for (int i = 0; i < size; i++)
	{
		printf("Enter  x(%d):", i);
		scanf("%lf", &x[i]);		
		printf("Enter fx(%d):", i);
		scanf("%lf", &fx[i]);
		printf("------\
");
	}
	printf("Please enter point to calculate:\
");
	scanf("%lf", &question);
	printf("\
");
	printf("Result =====> f(%4.2lf) = %5.4lf\
",question, Calculate(size, question));
	printf("\
");
	system("PAUSE");
}

double Lagrange(int n, int k, double val)
{
	double result = 1;
	for (int i = 0; i < n; i++)
	{
		if (i!=k)		
			result = result * (double)((val - x[i]) / (x[k] - x[i]));		
	}
	return result;
}

double Calculate(int n,double x)
{
	double intPolasyon = 0;
	double *L = (double*)malloc(sizeof(double)*n);
	double *F = (double*)malloc(sizeof(double)*n);
	for (int i = 0; i < n; i++)
	{
		L[i] = Lagrange(n, i, x);		
		intPolasyon += fx[i] * L[i];
		printf("L(%d) = %5.3lf\
", i, L[i]);
	}
	
	printf("\
");
	return intPolasyon;
}

Merhaba arkadaşlar, bu makalemde arduino ve aynı zamanda avr 8 bit mimarisine sahip işlemcilerde timer kullanımından bahsetmek istiyorum. Arduino adı altında toplanan nerdeyse tüm hazır boardlarda kullanılan işlemciler atmega firmasına ait olan avr-8 bit veya 32 bit işlemcileridir. Bu işlemcilerde timer kullanmaktan bahsetmeden önce bu mimariye sahip tüm işlemciler benzer şekilde ayarlamalar yapabileceğinizi belirtmek isterim. Her işlemcide benim örnek vererek anlatacağım timerlar bulunmayabilir.Bunun için gerekli bilgiyi kullandığınız işlemcinin datasheet dosyasından öğrenebilirsiniz. ( Ornek : Atmega328 ) Timer Nedir ? Timer belirli zaman aralıklarında yapmak istediğimiz olayların gerçekleşmesinde bize yardımcı olan yapıdır. İşlemciye o zaman dilimi geldiğinde ne yapması gerektiğini hatırlatır. Bu yapılacak işlem bir dizi kendi komutunuz yada timerın desteklediği spesifik bir özellik olabilir. Örneğin klasik bir örnek olan belirli zaman aralıklarında herhangi bir çıkışa bağlı led'i yakmak istediğinizde timer kullanmadığınızı varsayarsak bu işlemi gerçekleştirmek için geçen zamanı sürekli olarak kontrol edebilir yada delay gibi kaçılması gereken komutlarla o an işlemciyi bloke edebilirsiniz. Bunları yapmak yerine işlemcide var olan bu yapılar bize gereken zaman kontrolünü sağlamaktadırlar. Bunu yaparken işlemcide diğer paralel işlemlerin devam etmesi ise bize çoklu işlem yapabilme yeteneği kazandırıyor.   Timer Nasıl Çalışır ? Timerlar sayaç yazmacı olarak bilinen ( counter register ) değişkenini periyodik olarak arttırırlar. Bu yazmaç belirli bir değere kadar ulaşabilir. Bu değeri belirleyen faktör ise kullandığımız timer'ın kaç bit olduğudur. Genellikle 8 bit veya 16 bit olarak karşımıza çıkarlar. Bu yazmaç maksimum değerine ulaştığı zaman (8 bit ise bu değer 255 çünkü 0'dan başlıyor)  sıfıra resetlenir ve taşmanın olduğuna dair bir flag bit'i set edilir. Bu biti bizim takip etmemize gerek kalmadan Interrupt Service Routine (ISR) bu işlemi bizim için gerçekleştirerek bizim kesme olduğundan haberdar olmamızı sağlar. Bu flag bit'i için gereken tüm kontrolleri ISR sağlamaktadır. Peki timer counter değişkenini periyodik olarak artırır dedik. Bu periyotu neye göre referans alıp arttırır ? Timer çalışması için bir clock sinyaline ihtiyaç duyar. Bu sinyal her oluştuğunda bu değişkeni bir arttırır. Bu sinyal harici olabileceği gibi dahili olarakta çoğu işlemcide mevcuttur. Örneğin siz bir timer'a 16MHz clock sinyali sağlarsanız, bu timer için periyot : T = 1 / f ( Frekans Hz olarak ) T= 1 / ( 16* 10^6 Hz ) T = 62.5 ns Eğer 32Mhz olsaydı bu değer 31.25 ns olacaktır. ( 1 sn = 10^9 ns)   Yukarıda timerların genel çalışma mantığından bahsettik. 8-bit AVR işlemcilerinde birden çok timer mevcut. Her timer varsayılan olarak arduino için farklı işlemlerde kullanılmak üzere ayarlanmıştır. Timerlar üzerinden bilmeyerek yapabileceğimiz değişiklerle zaman bağımlı fonksiyonlarda beklenmedik sonuçlar ile karşılaşabiliriz. ( Motor, delay, millis vb.) Varsayılan Timer Ayarları Timer0 - 8-bit bir zamanlayıcıdır. Counter değişkeni maksimum 255 değerini alır. Arduino için gerekli temel fonksiyonlar( delay() ve millis() gibi ) bu timer'a bağlıdırlar. Bu timer üzerinde ne yaptığınızı bilmediğiniz sürece değişiklik yapmamak en iyisi olacaktır. Timer1 - 16-bit bir zamanlayıcıdır. Counter değişkeni maksimum 65535 değerini alır. Servo kütüphanesi bu zamanlayıcıyı kullanmaktadır. Timer2 - 8-bit bir zamanlayıcıdır. Counter değişkeni maksimum 255 değerini alır. tone() fonksiyonu bu zamanlayıcıyı kullanmaktadır. Kullandığınız işlemcide bunların dışında farklı Timer3, Timer4, Timer5 gibi zamanlayıcılar bulunabilir. Gerekli bilgileri önceden bahsettiğim gibi onların pdfleri üzerinden ulaşabilirsiniz. Genel anlamda yapacağımız ayarlamaların hepsi birbiri için geçerli olacaktır. Zamanlayıcı Yazmaçlarının Ayarlanması Timerlar için gerekli ayarların saklanacağı yazmaçlar vardır. Bunlar üzerinde yukarıda bahsettiğimiz ayarlamaların nasıl yapılacağını birazdan örnekler üzerinde daha iyi anlayacaksınız. Bu yazmaçlardan iki tanesini timer ayarlarını set ederken kullanırız. Bunlar TCCRxA ve TCCRxB'dir. Herbir yazmaç 8 bit veri saklar.Burada x yerine ayarlamak istediğiniz timer rakamını yazabilirsiniz. Aşağıda örnek olarak Timer1 için bu yazmaçlar verilmiştir.

Timer interrupt'ın periyotunu set ederken gerekli olan clock sinyalini 0 1 2 numaralı bitlerin kombinasyonlarıyla sağlarız.

Örneğin Timer1'i 2MHz clock hızında çalıştırmak istersek. Yani her count arttırımı için geçen süre 0.5us olacak biçimde ayarlarsak  aşağıdaki gibi bir kod bloğu yazmamız gerekir. Ben ornekleri arduino ide'si üzerinden anlatıyorum.

#define PIN 13 // Board üzerinde var olan led. Arduino Uno R3

void setup()
{
  pinMode(PIN, OUTPUT);
  //  Timer1 Ayarlanması
  cli();         // tüm interruptlar dev dışı
  TCCR1A = 0;    // tüm TCCR1A yazmacını sıfırlar
  TCCR1B = 0;    // tüm TCCR1B yazmacını sıfırlar

  // timer1 için overflow interruptını açar
  TIMSK1 |= (1 << TOIE1); //Kullandığınız işlemcide bu timer yoksa farklı bir timer ilede aynı ayarları set edebilirsiniz

  // CS11 bitini atadık vede timer şuanda clock hızında çalışacaktır.
  TCCR1B |= (1 << CS11); //  böleni 8 olarak ayarladık. Yani 16/8 = 2 MHZ

  sei();//Tüm interruptları çalıştır.

}

void loop()
{

}

Overflow Interrupt Burada yaptığımız ayarlamada timer'ın ne tür bir kesme kullanacağını belirtmedik. Bunun kontrolünü sağlayan Timer/Counter1 Interrupt Mask Register TIMSK1'dir. Bu yazmaca TOIE1 ataması yaparak timer'in taşma (overflow ) interruptı kullanmasını set ederiz. Biraz daha sonra farklı bir kesme türü olan CTC ( Clear Timer on Compare Match ) kesmesinden de bahsedeceğim. Şimdi kaldığımız yerden devam edecek olursak overflow oluştuğu zaman ISR(TIMER1_OVF_vect) çağrılır.Sonuç olarak :

#define PIN 13 // Board üzerinde var olan led. Arduino Uno R3

void setup()
{
  pinMode(PIN, OUTPUT);
  //  Timer1 Ayarlanması
  cli();         // tüm interruptlar dev dışı
  TCCR1A = 0;    // tüm TCCR1A yazmacını sıfırlar
  TCCR1B = 0;    // tüm TCCR1B yazmacını sıfırlar

  // timer1 için overflow interruptını açar
  TIMSK1 |= (1 << TOIE1); //Kullandığınız işlemcide bu timer yoksa farklı bir timer ilede aynı ayarları set edebilirsiniz

  // CS11 bitini atadık vede timer şuanda clock hızında çalışacaktır.
  TCCR1B |= (1 << CS11); //  böleni 8 olarak ayarladık. Yani 16/8 = 2 MHZ
  TIMSK1 | = (1 << TOIE1); // Overflow kesmesini açarız
  sei();//Tüm interruptları çalıştır.

}

void loop()
{

}
ISR(TIMER1_OVF_vect)
{

  digitalWrite(PIN, !digitalRead(PIN));

}

Buraya kadar olan bölümde kesme tanımlamasını oluşturduk. Kesme frekansını hepsaplayacak olursak:

• Clock sinyalimizi 8 böleni kullanarak ( CS11 ) set ettik yani 2MHz clock sinyali elde ettik
• Bir count değeri arttırmak için geçen süre 0.5us.
• Counter değeri 0 - 65535'e çıkarken 65536 değer arttırmış olur.
• T = 65536*0.5 =32.77ms olur
• f=1/T = 30.51 Hz

Yani bizim ISR fonksiyonumuz saniyede yaklaşık olarak 30.51 kere çalıştırılacak.   Overflow kesmesinin bazı dezavantajlarından birtanesi istediğimiz frekans değerlerinin tam olarak ayarlanabilmesinin zor olması. Çünkü her seferinde counter'ın sona kadar arttırılıp kesmenin oluşması beklenmekte. Bunun yerine daha hassas frekans oynamaları yapabilmek için timer'in bizim belirlediğimiz bir değere ulaşmasından sonra kesme oluşmasını sağlayabileceğimiz mod olan CTC modundan bahsetmek istiyorum.   Clear Timer on Compare Match Kesmesi ( CTC ) Timer'ın counter değerinin overflow yapmasını beklemek yerine, bizim daha önceden set ettiğimiz bir count değerine eşit olunca oluşan bir kesmedir. Burada bu değeri atayabileceğimiz register ACRxA'dır. Burada x seçeceğimiz timer'a göre farklılık göstermektedir. Aynı zamanda atayacağımız maksimum değer bu seçtiğimiz timer'ın kaç bit olduğuna göre değişir. Yine örnek olarak timer1 kullancak olursak atayacağımız değerler işaretsiz 65536'dan küçük değerler olmalıdır. Timer0 kullancak olursak bu değer 256'dan küçüktür. Bu modu kullanmanın diğer bir avantajı timer0 kullanırken default prescale (64 böleni) kullanırsak overflow kesmesinde herhangi bir değişiklik olmadığı için diğer temel fonksiyolar doğru çalışmaya devam edecektir. Yani timer0'ıda bu mod ile kesmelerde kullanabiliriz. Fakat 8 bit olmasından dolayı uyarlayabileceğimiz frekans aralıkları sınırlı olacaktır. Burada size istediğiniz frekansı elde edebileciğiniz bir formul vermek istiyorum. Bu formul ile istediğiniz frekansa ulaşmak için gereken adım sayısını kolayca hesaplayabilirsiniz. Formulde yer alan frekans değeri elde etmek istediğimiz frekanstır. Bölen daha önce bahsettiğimiz işlecinin clock hızını ayarladığımız değerdir. 1 çıkarmamızın nedeni 0'dan başlıyor olmasıdır. Şimdi bir örnek ile 16KHz kesme frekansı oluşturalım.

#define PIN 13 // Board üzerinde var olan led. Arduino Uno R3

void setup()
{
  pinMode(PIN, OUTPUT);
  //  Timer1 Ayarlanması
  cli();         // tüm interruptlar dev dışı
  TCCR1A = 0;    // tüm TCCR1A yazmacını sıfırlar
  TCCR1B = 0;    // tüm TCCR1B yazmacını sıfırlar

  TCCR1A |= (1 << WGM21); // CTC modunu aktif hale getirir
  // CS11 bitini atadık vede timer şuanda clock hızında çalışacaktır.
  OCR2A = 124;// ((16*10^6)/(16000*8))-1 Bize 16KHz kesme frekansı sağlar
  TCCR1B |= (1 << CS11); //  böleni 8 olarak ayarladık. Yani 16/8 = 2 MHZ clock sinyali
  TIMSK1 |= ( 1 << OCIE1A); // Timer Compare kesmesini aktif hale getir.
  sei();//Tüm interruptları çalıştır.

}

void loop()
{

}
ISR(TIMER1_COMPA_vect) // 16 KHz frekansa sahip.
{

  digitalWrite(PIN, !digitalRead(PIN)); // Aç kapa 2 kesme tuttuğu için çıkışta ölçeceğiniz değer 8KHz olacaktır.

}

  Kesmeler ile değişkenleri kullanırken dikkat edilmesi gereken önemli bir nokta ise volatile değimidir. Bu tanımlama ile değişkenlerde farklı kesmelerinin değişken üzerinde sıralı işlem yapmasını sağlayıp daha stabil güvenilir bir saklama yapmış oluruz. Çok yüksek frekans değerlerinde bu deyim yeterli olmayıp kesmeyi devre dışı bırakıp değişkeni okuyup tekrar açma işlemide uygulanabilir. Başka bir makalede görüşmek üzere hoşcakalın.      

• Mobil uygulamalar ile entegrasyonu
• Farklı uygulamalar ile doğrulamanın paylaşılabilmesi
• Durumsuz olması  ( Stateless ) ve sonucunda daha kolay ölçeklenebilir olması
• Front-end ile back-end arasında gevşek (loosely coupled) bir yapı sağlaması

Uygulama İle Devam Edelim... Örnek uygulamamızı oluştururken iki tane projeye ihtiyacımız olacak. Bir tanesi boş web-api projemiz ikincisi ise boş bir web projesi olacak.

Web Api Bearer Token  Authentication Projesi

Boş web-api projemizi "OrnekWebApi" şeklinde adlandırıp başlayalım.Projemize kullanacağımız paket eklentilerini yükleyelim. Bunlar için;

Install-Package Microsoft.AspNet.WebApi.Owin Install-Package Microsoft.Owin.Security.OAuth Install-Package Microsoft.Owin.Cors Install-Package Microsoft.Owin.Host.SystemWeb

Paket yüklemelerini gerçekleştirdikten sonra aşağıda şekilde görüldüğü gibi bir klasör yapısı oluşturup içerine "Saglayici" ve "Startup" klasımızı ekleyelim. Startup klasımız içine aşağıdaki kodları yapıştıralım.

using System;
using System.Web.Http;
using Microsoft.Owin;
using Microsoft.Owin.Security.OAuth;
using Owin;


[assembly: OwinStartup(typeof(OrnekWebApi.Authentication.Startup))]
namespace OrnekWebApi.Authentication
{
    public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            HttpConfiguration config = new HttpConfiguration();

            ConfigureOAuth(app);            
            WebApiConfig.Register(config);
            app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
            app.UseWebApi(config);
        }

        private void ConfigureOAuth(IAppBuilder app)
        {
            OAuthAuthorizationServerOptions oAuthAuthorizationServerOptions = new OAuthAuthorizationServerOptions()
            {
                TokenEndpointPath = new Microsoft.Owin.PathString("/token"), // token adresi
                AccessTokenExpireTimeSpan = TimeSpan.FromHours(10),//10 Saat geçerli
                AllowInsecureHttp = true,
                Provider = new Saglayici() // Burada hata alırsanızz saglayıcı klasınızız doğru ayarladığınızdan emin olun.
            };

            
            app.UseOAuthAuthorizationServer(oAuthAuthorizationServerOptions); // Ayarladığımız config dosyasının server'a kullanması için gönderiyoruz.
            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());// Bearer Authentication'ı kullanacağımızı belirttik.
        }
    }
}

  Burada yukarıda tanımladığımız assembly ile serverımız ilk çalıştığında çalıştırılacak klasımızı tanımladık.  Configuration kısmında yer alan parametre ise bu çağrılma sırasında host tarafından sağlanmakta. İkinci olarak HttpConfiguration ayarlarımızı yaptıktan sonra App_Start'da yer alan Register metodumuzu bu configrasyon ile çağıracağız.Bu işlemin ardından projemizde yer alan Global.asax.cs dosyamızın bulunmasına gerek kalmamaktadır. Çünkü startup işlemini artık buradan sağlıyoruz. OAuth server ayarlarında tanımladığımız özelliklerden bahsedecek olursak

TokenEndpointPath ile geçerli token alacağımız adresi belirtiyoruz. AccessTokenExpireTimeSpan ise sağlanan token'ın geçerlilik süresini belirtir. AllowInsecureHttp ise token requestlerin HTTPS olmayan protokollere açılmasını sağlar.

Şimdi ikinci klasımız olan sağlayıcı klasımız için kodları paylaşalım.

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.Owin.Security.OAuth;
namespace OrnekWebApi.Authentication
{
    public class Saglayici : OAuthAuthorizationServerProvider
    {
        public override async Task ValidateClientAuthentication(OAuthValidateClientAuthenticationContext context)
        {
//Burada client validation kullanmadık. İstersek custom client tipleri ile client tipine görede validation sağlayabiliriz.
            context.Validated();
        }

        public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
        {

            context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); // Farklı domainlerden istek sorunu yaşamamak için

            //Burada kendi authentication yöntemimizi belirleyebiliriz.Veritabanı bağlantısı vs...
            if (context.UserName == "Sinan" && context.Password == "Bir")
            {
                var identity = new ClaimsIdentity(context.Options.AuthenticationType);

                identity.AddClaim(new Claim("name", context.UserName));
                identity.AddClaim(new Claim("yetki", "Admin"));

                context.Validated(identity);
            }
            else
            {
                context.SetError("Geçersiz istek", "Hatalı kullanıcı bilgisi");
            }

            

        }
    }
}

  Şimdi son olarak Authentication'ı test edebileceğimiz bir controller oluşturup projenin web-api kısmını tamamlamak."Fatura" isminde boş bir web-api 2 controller oluşturalım.

using System.Collections.Generic;
using System.Web.Http;


namespace OrnekWebApi.Controllers
{
    public class FaturaController : ApiController
    {
        [HttpGet]
        [Authorize]
        public IEnumerable<string> Get()
        {
            var firmaList = new List<string>()
            {
                "Firma 1",
                "Firma 2",
                "Firma 3",
            };
            return firmaList;
        }   
    }
}

Burada [Authorize] attribute'i ile get metodumuzun yetkilendirme gerektireceğini belirttik. Buraya kadarki bölümde web-api projemizi tamamladık. Şimdi projemizi test etmek için boş bir web projesi açıp yapılandırmalara devam edelim.   Web Projemiz Boş bir web-mvc projesi açalım. Projemize birtek jquery yüklememiz yeterli.  Ardından aşağıda vereceğim java script kodunu ekleyin.

$(document).ready(function() {
    $("#Login").click(function() {
        var userName = $("#UserName").val();
        var password = $("#Password").val();
        
        $.ajax({
            url: "http://localhost:11050/token",
            type: "POST",
            crossDomain: true,
            data: {
                "username": userName,
                "password": password,
                "grant_type": "password"
            },
            dataType: "json",
            success: function (result) {
                alert("Logged in successfully");
                localStorage.setItem('Token', JSON.stringify(result));
            },
            error: function (xhr, status, error) {
                alert(status+" " +error);
            }
        });
        
    });
    $("#Logout").click(function () {
        if (localStorage.getItem('Token')==null) {
            alert("You already logged out");
            return;
        }
        alert("Logged out successfully");
        localStorage.removeItem('Token');
    });
    $("#Get").click(function () {
        var token = $.parseJSON(localStorage.getItem('Token'));
        if (token == null) {
            alert("Unauthorized Request");
            return;
        }
        var accessToken = token.access_token;
        
       
        $.ajax({
            url: "http://localhost:11050/api/Fatura",
            type: "Get",
            crossDomain: true,
            dataType: "json",
            headers: {
                "accept": "application/json",
                "content-type": "application/json",
                "authorization": "Bearer "+ accessToken
                },
            success: function (result) {
                alert(JSON.stringify(result));
            },
            error: function (xhr, status, error) {
                alert(status + " " + error);
            }
        });
    });
});

  Burada serverdan dönen token'ı local storage kaydettim. Siz farklı bir yapıda kullanabilirsiniz. Index sayfası için kodları paylaşıyorum.

<!DOCTYPE html>

<html>
<head>
    <meta name="viewport" content="width=device-width"/>
    <script src="~/Scripts/jquery-2.1.4.min.js"></script>
    <script src="~/App/App.js"></script>
    <title>Index</title>
</head>
<body>
<input id="UserName" type="text" value="Sinan"/>
<input id="Password" type="password" value="Bir"/>
<input id="Login" type="button" value="Login"/>
<input id="Logout" type="button" value="Logout" />
<input id="Get" type="button" value="Get Data" />

</body>
</html>

    Giriş yaptığınızda sonuç aşağıdaki gibi olacaktır. Veri isteği yaptığımızdaki sonuç Proje dosyaları github'da mevcuttur.  

Install-Package NLog

yazarak eklentiyi yükleyelim. Daha sonra proje klasorüne nlog için gerekli olan NLog.config dosyasını ekleyelim ve içine aşağıdaki kodları yapıştıralım.

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" throwExceptions="true" >

  <variable name="logDirectory"  value="${basedir}/logs/${shortdate}" />
  <targets async="true"> 
    
      <target name="FileManager"
              xsi:type="File"
              layout="${longdate} ${threadid:padding=4} ${level:uppercase=true:padding=5} ${logger} ${message} ${exception:format=tostring}"
              fileName="${logDirectory}/log.txt"
              archiveFileName="${logDirectory}/log.{#}.txt"
              archiveEvery="Day"
              archiveNumbering="Rolling"
              maxArchiveFiles="7"
              concurrentWrites="true"
              createDirs="true"
              autoFlush="true" />
     <target name="FileManager2"
              xsi:type="File"
              layout="${longdate} ${threadid:padding=4} ${level:uppercase=true:padding=5} ${logger} ${message} ${exception:format=tostring}"
              fileName="${logDirectory}/log2.txt"
              archiveFileName="${logDirectory}/log.{#}.txt"
              archiveEvery="Day"
              archiveNumbering="Rolling"
              maxArchiveFiles="7"
              concurrentWrites="true"
              createDirs="true"
              autoFlush="true" />

     
  </targets>
  <rules>
    <logger name="*" minlevel="Trace" maxlevel="Warn" writeTo="FileManager" />
  <logger name="*" minlevel="Error" writeTo="FileManager2" />
  </rules>
</nlog>

Burada config dosyasında değinmek istediğim bazı noktalar var. Rules bölümünde kurallar oluşturabiliyoruz. Bu kurallar içerisinde "minlevel" loglama işleminin hangi seviyeden sonra gerçekleşeceğini tanımlıyor.Aynı şekilde "maxlevel" özelliğinide tanımlayabiliriz. Bu seviyeler aşağıdaki gibi :

  İkinci bir önemli özellik ise "writeTo". Bununla loglama kuralı için hangi target sistemini kullanacağını belirtiyoruz. Biz target olarak dosyalamaya uygun ayarları kullanacağız.Bu ayarları yaptıktan sonra config dosyasındaki tanımlamada throwExceptions="true" olması olası config hatalarını görmemizde bize yardımcı olacaktır. Program bitişinde bunun false yapılmasında fayda var.Çünkü uygulama çalışırken hata yada bilgilendirme için kullandığımız eklentinin de hata vermesini istemeyiz. Şimdi örnek bir program ile çıktıları kontrol edelim.

static void Main(string[] args)
        {
            var logger = NLog.LogManager.GetCurrentClassLogger();
            // Trace - Warn levelları arasında FileManager2'yi kullanacak.
            logger.Log(LogLevel.Info, "Sample Info error message");
            logger.Log(LogLevel.Debug, "Sample Debug");
            logger.Log(LogLevel.Warn, "Sample Warn");
            logger.Log(LogLevel.Trace, "Sample Trace");
            //Error ve yukarısı için FileManager'ı kullanacak.
            logger.Log(LogLevel.Error, new Exception("Hata1"));
            logger.Log(LogLevel.Error, new Exception("Hata2"));
            
        }

Programı çalıştırdıktan sonra. Dosyaları kontrol ettiğimizde çıktı aşağıdaki gibi olacaktır.   Gördüğünüz gibi farklı seviye hatalar için farlı dosyalar tuttuk. Burada biz target olarak dosya seçtik eğer mail seçmiş olsaydık aynı çıktıları mail olarak alabilirdik. Detaylı target configrasyonlarını framework sitesinde bulabilirsiniz. Başka bir makalede görüşmek üzere. Hoşçakalın.    

Install-Package SimpleInjector.Integration.WebApi

komutunu yazıp eklentiyi projemize dahil edelim. Örnek olarak kullanacağımız dependcyleri oluşturalım. Dependcies.cs dosyamıza aşağıdaki kod bloğunu ekleyelim.

public interface IUserDataRepository
        {
            List<Data> GetDatas();
        }

        public class SqlUserRepository : IUserDataRepository
        {
            public List<Data> GetDatas()
            {
                return new List<Data>()
                {
                    new Data() {Name = "Ali",Surname = "Devil",Age = 22},
                    new Data() {Name = "Veli",Surname = "Devil2",Age = 45},
                    new Data() {Name = "Hasan",Surname = "Devil3",Age = 36}
                };
            }
        }
        public class NoSqlUserRepository : IUserDataRepository
        {
            public List<Data> GetDatas()
            {
                return new List<Data>()
                {
                    new Data() {Name = "Elif",Surname = "Angel1",Age = 21},
                    new Data() {Name = "Nihal",Surname = "Angel2",Age = 75},
                    new Data() {Name = "Tuğba",Surname = "Angel3",Age = 45}
                };
            }
        }

        public class Data
        {
            public string Name  { get; set; }
            public string Surname { get; set; }
            public int Age { get; set; }
        }

Şimdi App_Start klasorunde yer alan WebApiConfig.cs dosyamıza geçelim ve Simple Injector ayarlarını yapalım.

public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            var container = new Container();
            container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
            container.Register<IUserDataRepository, SqlUserRepository>(Lifestyle.Scoped);
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.Verify();
            GlobalConfiguration.Configuration.DependencyResolver =
                new SimpleInjectorWebApiDependencyResolver(container);
            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }

Şimdi yeni boş "user" adında bir controller oluşturalım.

public class UserController : ApiController
    {
        public IUserDataRepository UserDataRepository;

        public UserController(IUserDataRepository userDataRepository)
        {
            UserDataRepository = userDataRepository;
        }

        [HttpGet]
        public IEnumerable<Data> Get()
        {
            return UserDataRepository.GetDatas();
        }  
    }

Projemizi start edelim vede browserdan kendi localhost portunuza göre istek yapalım. vede gördüğünüz gibi veriler geldi.Injector bizim register ettiğimiz classımızı controller'a otomatik olarak bağladı.Ornekte browser XML olarak istediği için veri XML geldi. Siz kendiniz başka bir program kullanarak controller üzerinde  hiçbir değişiklik yapmadan sadece isteğin headerını değiştirerek JSON olarak veriyi alabilirsiniz.Web api bunu sizin için yapıyor. Dependcy register işlemini uygulama başlangıcında yaptık.Ornek olarak biz IUserDataRepository için SqlUserRepository concrete class'ını kullanıyoruz. Bunu NoSqlUserRepository olarak değiştirdinizde verilerinde değişeceğini göreceksiniz. Burada bir diğer önemli konu ise öğenin yaşam süreci.Simple Injection için 3 adet süreç mevcut. Bunlar Transient,Scoped,Singleton.Burada biz scoped kullandık. Her istek için bize servisin yeni bir örneği geliyor.Bunu örnek üzerinden anlatırsak daha anlaşılır olabilir. Bunun için kod üzerinde bazı değişiklikler yapalım. Aşağıda değişiklik yapılan kodları yeniden paylaşıyorum

public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            var container = new Container();
            container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
            container.Register<IUserDataRepository, SqlUserRepository>(Lifestyle.Scoped);
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.Verify();
            GlobalConfiguration.Configuration.DependencyResolver =
                new SimpleInjectorWebApiDependencyResolver(container);
            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }

public interface IUserDataRepository
    {
        List<Data> GetDatas();
        void AddData(Data data);

    }

    public class SqlUserRepository : IUserDataRepository
    {
        public List<Data> List { get; set; }

        public SqlUserRepository()
        {
            List = new List<Data>()
                {
                    new Data() {Name = "Ali",Surname = "Devil",Age = 22},
                    new Data() {Name = "Veli",Surname = "Devil2",Age = 45},
                    new Data() {Name = "Hasan",Surname = "Devil3",Age = 36}
                };
        }
        public List<Data> GetDatas()
        {
            return List;
        }

        public void AddData(Data data)
        {
            List.Add(data);
        }
    }
    public class NoSqlUserRepository : IUserDataRepository
    {
        public List<Data> List { get; set; }

        public NoSqlUserRepository()
        {
            List = new List<Data>()
                {
                    new Data() {Name = "Elif",Surname = "Angel1",Age = 21},
                    new Data() {Name = "Nihal",Surname = "Angel2",Age = 75},
                    new Data() {Name = "Tuğba",Surname = "Angel3",Age = 45}
                };
        }
        public List<Data> GetDatas()
        {
            return List;
        }

        public void AddData(Data data)
        {
            List.Add(data);
        }
    }

    public class Data
    {
        public string Name { get; set; }
        public string Surname { get; set; }
        public int Age { get; set; }
    }

  public class UserController : ApiController
    {
        public IUserDataRepository UserDataRepository;

        public UserController(IUserDataRepository userDataRepository)
        {
            UserDataRepository = userDataRepository;
        }

        [HttpGet]
        public IEnumerable<Data> Get()
        {
            return UserDataRepository.GetDatas();
        }

        [HttpPost]
        public void AddData(Data data)
        {
            UserDataRepository.AddData(data);
        }
    }

Gördüğünüz gibi sadece AddData fonksiyonunu ekledik ve config dosyasında route ayarlarında action parametresini ekledik. Bu değişiklikleri yaptıktan sonra projeyi çalıştıralım ve bir post işlemi yapalım. Örnek Post Çağrısı:

POST http://localhost:62066/api/user/AddData HTTP/1.1 User-Agent: Fiddler Host: localhost:62066 Content-Length: 42 Content-Type: application/json; charset=utf-8 {"Name":"Sinan","Surname":"Bir","Age":100}

Post işleminden sonra normalde User controller'a get çağrısı yaptığımızda dönen yanıtlar içinde  {"Name":"Sinan","Surname":"Bir","Age":100} bu kayıdın olması gerekiyor di mi ? Ama hayır biz her istek yaptığımızda container bize servisin yeni bir örneğini veriyor. Yani biz her seferinde ilk listeye erişmiş oluyoruz. Eğer life scoped değilde singleton olsaydı ne olurdu ? Bu sefer servisin sadece bir örneğini container'ın life time'ı boyunca bize verecekti. Biz farklı istekler de yapsak işlemlerin hepsi aynı nesne üzerinde işlem görecekti. Aynı çağrıyı webconfig dosyasındaki isteği singleton olarak değiştirip yaptığımızda kaydın eklendiğini görebiliriz. Simple injector kullanmamın nedeni diğer IOC frameworklere göre biraz daha performanslı ve çoğu durumda işimizi çözüyor. Bugunluk bahsedeceklerim bunlar. Bir başka makale ile görüşmek üzere. Hoşcakalın.  

Install-Package FluentValidation

yazarak yükleyebilirsiniz. Örnek ( Example)

    public class Company
    {
        public string CompanyName { get; set; }
        public string EMail { get; set; }
        public string Phone { get; set; }
        public double AnnualIncome { get; set; }
        public string Address { get; set; }
        public List<Employee> Employees { get; set; }
    }

    public class Employee
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Gender { get; set; }
    }

 public class CompanyValidation : AbstractValidator<Company>
    {
        public CompanyValidation()
        {
            RuleFor(a => a.CompanyName).NotEmpty().Length(0, 8).WithMessage("You exceeded the maximum char limit");
                //Hatayı test etmek için küçük değer kullanıyorum
            RuleFor(a => a.Address).NotEmpty().Length(0, 250);
            RuleFor(a => a.EMail).EmailAddress().WithMessage("Invalid EMail");
            RuleFor(a => a.AnnualIncome).GreaterThan(0).LessThanOrEqualTo(5000000);
            RuleFor(a => a.Employees).SetCollectionValidator(new EmployeeValidation());
            //Collection için normal validation bile kullanabiliyorsunuz
        } 
    }

    public class EmployeeValidation : AbstractValidator<Employee>
    {
        public EmployeeValidation()
        {
            RuleFor(e => e.Age).GreaterThan(18).LessThanOrEqualTo(150);
            RuleFor(e => e.Name).NotEmpty();
        }
    }

        static void Main(string[] args)
        {
            var companyValidator = new CompanyValidation();
            var company = new Company();
            company.Employees= new List<Employee>();
           
            company.Employees.Add(new Employee());
            company.Employees.Add(new Employee() {Age = 255,Name = "Ali",Gender = "Male"});
            var validation = companyValidator.Validate(company);
            var errors = validation.Errors;
            var state = validation.IsValid;
            Console.WriteLine(state);
            foreach (var error in errors)
            {
                Console.WriteLine(error.PropertyName +"-"+ error);
            }
            Console.WriteLine("-----------------");
            Console.ReadLine();

        }

Program Çıktısı Gördüğünüz gibi model sınıflarımızı temiz bırakarak ( POCO  sınıflar ) validation sağladık. Validation için detaylı bilgi için tıklayınız   Başka bir makalede görüşmek üzere. Hoşçakalın.

    public class Information
    {
        Email InformationSender { get; set; }
               
        public Information(Email email)
        {
            InformationSender = email;
        }
        public void SendInformation()
        {
            InformationSender.Send();
        }
    }

    public class Email
    {
        public void Send()
        {
            Console.WriteLine("Bildirim");
        }
    }

static void Main(string[] args)
        {
            Information information = new Information(new Email());
            information.SendInformation();
            Console.ReadLine();
        }

Program Çıktısı : Yukarıdaki kodu çalıştırdığımızda programımız çalışacaktır. Fakat burada oluşan problem Information sınıfımız Email sınıfımız ile bağlı yani Information sınıfını Email sınıfı olmadan kullanmak mümkün değil. Veya ilerde programa bir başka bilgilendirme sistemi eklemek istediğimizde, örneğin sms bilgilendirmesi, Information sınıfı üzerindeki kod bloklarında düzenleme yapmak kaçınılmaz olacaktır. Email sınıfındaki değişiklikler doğrudan Information sınıfını etkilemekte. Sınıflar arasındaki bu derece sıkı bağlılıklar kod düzenlemesini zorlaştırmakta ve büyük projelerde karmaşıklığa sebep olmakta. Şimdi örnek bir kod bloğu ile dependcy injection'ı anlatmaya çalışacağım. Injection yöntemi olarak constructor injection kullanacağım. Bunun dışında siz isterseniz property injection da kullanabilirsiniz.

    public class Information
    {
        ISender InformationSender { get; set; }
               
        public Information(ISender informationSender)
        {
            InformationSender = informationSender;
        }
        public void SendInformation()
        {
            InformationSender.Send();
        }
    }

    public interface ISender
    {
        void Send();
    }

    public class Email : ISender
    {
        public void Send()
        {
            Console.WriteLine("Email Bildirim.");
        }
    }

    public class Sms : ISender
    {
        public void Send()
        {
            Console.WriteLine("Sms Bildirim.");
        }
    }

        static void Main(string[] args)
        {
            Information mailInformation = new Information(new Email());
            mailInformation.SendInformation();
            Console.WriteLine("----------------------------");
            Information smsInformation = new Information(new Sms());
            smsInformation.SendInformation();
            Console.ReadLine();
        }

Gördüğünüz gibi artık information sınıfımızın diğer hiçbir alt sınıf ile doğrudan bağımlılığı kalmadı. Information sınıfı için tek bağımlılık ISender inteface'i. Information sınıfında ISender interface'ini implemente eden yüzlerce farklı concrete sınıfı kullabiliriz. Projede isteklerin hiçbir zaman sabit kalmaması , genişlemelerin çok olmasını göz önüne alarak Dependcy Injection'ın önemimin ne derece fazla olduğunu göstermekte. Blogumda ilk makale olmasıda benim için ayrı heycan verici. Bir başka makale ile beraber olmak üzere hoşçakalın.